Posts on Kernel Notes

PostgresInternal

Fri, 11 Sep 2026 15:06:30 +0800

Postgres Internals 14 阅读笔记

Egor Rogov 的 PostgreSQL 14 Internals 读书笔记入口。中文在线版方便查阅，英文 PDF 方便离线精读。

资料

中文在线版：PostgreSQL 14 Internals（中文）
英文 PDF（本站电子书库）：postgresql_internals-14_parts1-3_en.pdf

PostgreSQL 14 Internals (EN, Parts 1–3) 新窗口打开下载

数据组织

数据库

当初始化一个 PG 实例之后，PGDATA 会自动创建以下三种基础数据库：

template0: 用来通过逻辑复制，或创建不同编码数据库的原型/样板；
template1: 用户在此实例下创建所有其他数据库的模版，新建库都基于它；
postgres: 自带的一个常规库；

安全架构

Thu, 11 Jun 2026 10:50:00 +0800

4 安全架构

4.1 威胁模型

| STRIDE类别 | 威胁描述 | 针对的生命周期阶段 | 对应安全功能（章节） |
|------------|----------|------------------|----------------------|
| **S** 欺骗 | 攻击者伪造合法用户/系统身份 | 访问、传输 | 身份认证、安全传输（TLS/TLCP） |
| **T** 篡改 | 攻击者修改数据或代码 | 传输、计算、存储 | 安全传输、数据防篡改（账本表）、全密态加密、审计日志防篡改 |
| **R** 否认 | 用户否认执行过某操作 | 所有阶段 | 安全审计（不可否认记录） |
| **I** 信息泄露 | 敏感数据被未授权读取 | 访问、传输、计算、存储 | 访问控制、安全传输、透明加密、全密态加密、机密计算、数据脱敏 |
| **D** 拒绝服务 | 攻击者使系统不可用 | 访问、网络 | 网络ACL、SQL防火墙（阻断异常大查询） |
| **E** 权限提升 | 普通用户获得更高权限 | 访问、计算 | 访问控制（三权分立、最小权限）、数据库防火墙 |

角色	动机	目标	技术	分类
黑客	售卖获利	鉴别数据	不可信IP登录	欺骗
内部运维人员	勒索获利	用户表	暴力破解	篡改
内部研发人员	情报窃取	系统表	凭证重放	否认
系统维护人员	蓄意报复	事务日志	默认账户攻击	信息泄露
供应链	规避审计	审计日志	过期账号攻击	拒绝服务
网络中间人	炫耀技能	内存数据	弱口令攻击	权限提升
机房管理人员	人为过失	配置文件	内存凭证残留	-
-	-	-	认证耗尽	-
-	-	-	密码泄露	-
-	-	-	数据泄露	-
-	-	-	流量伪造	-
-	-	-	流量重放	-
-	-	-	密钥泄露	-
-	-	-	证书伪造	-
-	-	-	身份伪造	-
-	-	-	未授权访问	-
-	-	-	越权访问	-
-	-	-	权限提升	-
-	-	-	权限滥用	-
-	-	-	磁盘窃取	-
-	-	-	恶意软件	-
-	-	-	系统隔离失效	-
-	-	-	文件篡改	-
-	-	-	日志伪造	-
-	-	-	特权窥探	-
-	-	-	供应链后门	-
-	-	-	内存嗅探	-
-	-	-	调试工具滥用	-
-	-	-	操作抵赖	-
-	-	-	攻击隐匿	-
-	-	-	合规证据缺失	-

攻击者画像	攻击动机	攻击阶段	攻击类型	攻击目标	攻击技术（ATT&CK）	影响的安全域（GB/T 20273）	风险等级	安全功能与标准映射
外部渗透测试者	数据窃取	侦察	欺骗(S)	认证凭据	暴力破解(T1110)	身份鉴别(4.1)	高	身份认证；GB/T 20273 4.1；ISO 27001 A.9；NIST IA-5
内部恶意DBA	数据篡改	武器化	篡改(T)	会话令牌	中间人攻击(T1557)	传输数据保密性(4.8.2)	高	TLS双向认证；GB/T 20273 4.8.2；ISO 27001 A.13.2；NIST SC-8
内部开发人员	权限提升	投递	否认(R)	数据字典	账户操纵(T1098)	安全审计(4.6)	高	统一审计；GB/T 20273 4.6；ISO 27001 A.12.4；NIST AU-3
第三方运维人员	拒绝服务	利用	信息泄露(I)	用户表数据	SQL注入(T1190)	自主访问控制(4.2)	高	数据脱敏；GB/T 20273 4.2；PCI DSS 3.2
网络中间人	规避审计	安装	拒绝服务(D)	审计日志	日志清除(T1070)	用户数据完整性(4.7)	高	审计日志防篡改；GB/T 20273 4.7；ISO 27001 A.12.4；NIST AU-9
云租户（恶意）	勒索	命令与控制	权限提升(E)	存储过程/函数	服务器软件组件劫持(T1505)	强制访问控制(4.4)	中	最小权限原则；GB/T 20273 4.4；NIST AC-6
恶意应用程序	报复	目标达成	-	备份集	数据加密（防御绕过）(T1022)	存储数据保密性(4.8.1)	高	透明加密(TDE)；GB/T 20273 4.8.1；ISO 27001 A.10.1
恶意OS管理员	间谍活动	-	-	内存中的明文	进程注入(T1055)	标记(4.3)	高	机密计算(TEE)；NIST SC-3
物理入侵者	误操作	-	-	配置文件	系统信息发现(T1082)	可信路径(4.9)	中	网络ACL；GB/T 20273 4.9；ISO 27001 A.13.1
-	身份伪造	-	-	数据导出文件	数据破坏(T1485)	-	低	备份加密
-	会话劫持	-	-	数据库链接	服务停止(T1489)	-	-	SQL防火墙
-	-	-	-	索引/分区	通过API攻击(T1559)	-	-	行级安全(RLS)
-	-	-	-	物化视图	客户端连接劫持(T1184)	-	-	列级加密
-	-	-	-	同义词	网络嗅探(T1040)	-	-	三权分立
-	-	-	-	触发器等对象	创建账户(T1136)	-	-	密钥管理(KMS/HSM)
-	-	-	-	临时表空间	数据从本地拉取(T1213)	-	-	全密态执行
-	-	-	-	Undo日志	禁用安全工具(T1562)	-	-	权限分析工具
-	-	-	-	控制文件	受信关系利用(T1199)	-	-	-
-	-	-	-	监听器/端口	反向工程(T1598)	-	-	-
-	-	-	-	SSL证书私钥	数据加密(自身通讯)(T1573)	-	-	-
-	-	-	-	数据库参数	域策略修改(T1484)	-	-	-
-	-	-	-	数据库进程内存	-	-	-	-
-	-	-	-	数据快照	-	-	-	-
-	-	-	-	数据库服务端口	-	-	-	-

gemini

攻击者画像	攻击动机	攻击阶段 (Kill Chain)	攻击类型 (STRIDE)	攻击目标 (数据库资产)	攻击技术（MITRE ATT&CK）	ISO 15408 (CC) 功能组件映射	商业标杆对标 (Oracle企业版组件)	本内核架构防御机制基线
外部黑客/APT组织	经济利益(勒索/售卖)	侦察 (Recon)	欺骗(Spoofing)	认证凭据 (Hash/密码)	T1190 利用面向公众的应用	FIA_UAU.2 (用户鉴别)	Oracle Centrally Managed Users (CMU)	统一身份认证与多因素(MFA)
内部恶意超管/DBA	商业间谍(数据窃密)	武器化 (Weaponization)	篡改(Tampering)	数据文件(MDF/PGDATA)	T1110 暴力破解	FCS_COP.1 (密码运算)	Oracle Advanced Security (TDE)	透明数据加密 (TDE)
内部研发/测试人员	蓄意破坏(报复社会)	投递 (Delivery)	否认(Repudiation)	WAL/Redo/Undo日志	T1098 账户操纵	FAU_GEN.1 (审计数据产生)	Oracle Audit Vault and DB Firewall (AVDF)	高性能异步统一审计与防篡改日志
供应链/第三方运维	掩盖罪行(规避审计)	漏洞利用 (Exploitation)	信息泄露(Info Disclosure)	系统目录/数据字典	T1078 有效账户(默认/后门)	FDP_ACC.1 (子集访问控制)	Oracle Database Vault (Realm特权隔离)	强三权分立与安全堡垒(Realm)隔离
网络中间人(MITM)	炫耀技能(黑客主义)	安装/植入 (Installation)	拒绝服务(DoS)	业务表核心数据	T1059 命令行解释器提权	FDP_DAU.1 (基本数据鉴别)	Oracle Blockchain Tables / Immutable Tables	数据防篡改内核账本 (Ledger Hash)
恶意云租户/邻居	误操作(配置失误)	命令与控制 (C2)	特权提升(Elevation)	审计日志记录	T1552 访问非安全凭据	FMT_SMR.1 (安全管理角色)	Oracle Label Security (OLS)	强制访问控制 (MAC 安全标签)
恶意OS管理员	资源盗用(挖矿)	横向移动 (Lateral Move)	侧信道探测(Side-Channel)	密钥/证书/Keystore	T1040 网络嗅探	FDP_RIP.1 (残余信息保护)	Oracle Advanced Security (Data Redaction)	动态数据脱敏 (DDM)
物理机房入侵者	合规性破坏(名誉打击)	目标达成 (Actions)	-	存储过程/UDF/扩展插件	T1557 中间人攻击	FCS_CKM.1 (密码密钥产生与管理)	Oracle Key Vault (OKV)	两级密钥管理架构 (KMS/HSM对接)
失陷的业务程序	-	-	-	数据库进程内存 (SGA)	T1070 清除审计日志	FPT_ITT.1 (内部TOE传输保护)	Oracle Virtual Private Database (VPD)	行级安全 / 列级安全 (RLS / CLS)
离职/僵尸账号	-	-	-	监听器/暴露网络端口	T1486 影响数据加密(勒索)	FTA_TSE.1 (TOE会话建立)	Oracle Data Safe (合规评估与发现)	敏感数据发现与分类分级扫描
-	-	-	-	会话令牌/Session	T1485 数据破坏(删库)	FPT_PHP.3 (抗物理攻击的TSF)	Always Encrypted (SQL Server标杆)	硬件级机密计算 (TEE/SGX 内核隔离)
-	-	-	-	DBLink/跨库链接	T1005 收集本地系统数据	-	-	全密态执行引擎 (内存密态运算)
-	-	-	-	物理备份集/快照	T1565 数据逻辑操纵	-	-	全链路 TLS 1.3 / 国密 TLCP 加密通道
-	-	-	-	视图/物化视图/触发器	T1184 客户端连接劫持	-	-	细粒度网络准入 (IP/用户元组控制)
-	-	-	-	数据库配置文件	-	-	-	内核级 SQL 防火墙 (基于AST白名单)
-	-	-	-	临时表空间(Temp)	-	-	-	-

deepseek

攻击者画像	攻击动机	攻击阶段	攻击类型 (STRIDE)	攻击目标	攻击技术 (ATT&CK)	影响的安全域 (GB/T 20273-2019)	风险等级	安全功能与标准映射（示例）
外部渗透测试者	数据窃取	侦察	欺骗 (S)	认证凭据	暴力破解 (T1110)	身份鉴别 (4.1)	高	多因素认证；GB/T 20273 4.1；ISO 27001 A.8.5
内部恶意DBA	权限提升	武器化	篡改 (T)	会话令牌	SQL注入 (T1190)	自主访问控制 (4.2)	中	TLS双向认证；GB/T 20273 4.7.2；NIST SC-8
内部开发人员	数据篡改	投递	否认 (R)	数据字典	中间人攻击 (T1557)	强制访问控制 (4.4)	低	统一审计；GB/T 20273 4.5；ISO 27001 A.8.15
第三方运维人员	拒绝服务	利用	信息泄露 (I)	用户表数据	账户操纵 (T1098)	安全审计 (4.5)	-	数据脱敏；PCI DSS 3.2
网络中间人	规避审计	安装	拒绝服务 (D)	审计日志	日志清除 (T1070)	用户数据完整性 (4.6)	-	审计日志防篡改；NIST AU-9
恶意应用程序	勒索	命令与控制	权限提升 (E)	存储过程/函数	进程注入 (T1055)	存储数据保密性 (4.7.1)	-	最小权限原则；GB/T 20273 4.4；NIST AC-6
恶意OS管理员	报复	目标达成	-	备份集	服务器软件组件劫持 (T1505)	传输数据保密性 (4.7.2)	-	透明加密 (TDE)；ISO 27001 A.8.24
物理入侵者	间谍活动	持久化	-	内存中的明文	数据加密（影响）(T1485)	可信路径 (4.8)	-	机密计算 (TEE)；NIST SC-3
云租户（恶意）	误操作	收集	-	配置文件	系统信息发现 (T1082)	网络安全 (4.9)	-	网络ACL；GB/T 20273 4.9
恶意内部员工	身份伪造	渗出	-	数据导出文件	服务停止 (T1489)	-	-	备份加密；DLP
外部攻击者	会话劫持	物理访问	-	数据库链接	数据破坏 (T1485)	-	-	SQL防火墙；连接限制
内部运维人员	侦察	-	-	索引/分区	通过API攻击 (T1559)	-	-	行级安全 (RLS)
内部用户	-	-	-	物化视图	客户端连接劫持 (T1184)	-	-	列级加密
-	-	-	-	同义词	网络嗅探 (T1040)	-	-	三权分立
-	-	-	-	触发器等对象	创建账户 (T1136)	-	-	密钥管理 (KMS/HSM)
-	-	-	-	临时表空间	数据从本地拉取 (T1213)	-	-	全密态执行
-	-	-	-	Undo日志	禁用安全工具 (T1562)	-	-	权限分析工具
-	-	-	-	控制文件	受信关系利用 (T1199)	-	-	不可变备份
-	-	-	-	监听器/端口	反向工程 (T1598)	-	-	配置基线检查
-	-	-	-	SSL证书私钥	数据加密(自身通信) (T1573)	-	-	端口隐藏
-	-	-	-	数据库参数	域策略修改 (T1484)	-	-	内存加密
-	-	-	-	数据库进程内存	内存刮削 (T1535)	-	-	快照加密
-	-	-	-	数据快照	数据泄露 (T1213)	-	-	文件系统权限
-	-	-	-	数据库服务端口	端口扫描 (T1046)	-	-	-

攻击者画像	攻击动机	攻击阶段 (Kill Chain)	攻击类型 (STRIDE)	攻击目标 (数据库资产)	攻击技术 (ATT&CK)	影响的安全域 (GB/T 20273-2019)	风险等级	安全功能与标准映射（含商业组件 & 内核防御）
外部黑客/APT组织	经济利益（勒索/售卖）	侦察	欺骗 (S)	认证凭据（密码Hash/票据）	暴力破解 (T1110)	身份鉴别 (4.1)	高	多因素认证；Oracle CMU；ISO 27001 A.8.5；NIST IA-5 → 统一身份认证与MFA内核模块
网络中间人	会话劫持	利用	篡改 (T)	会话令牌/Cookie	中间人攻击 (T1557)	传输数据保密性 (4.7.2)	高	TLS双向认证；Oracle Advanced Security；GB/T 20273 4.7.2；NIST SC-8 → 全链路TLS 1.3/国密TLCP加密通道
内部恶意DBA	商业间谍（数据窃密）	武器化	否认 (R)	数据字典/系统编目	账户操纵 (T1098)	安全审计 (4.5)	高	统一审计+防篡改日志；Oracle Audit Vault；GB/T 20273 4.5；ISO 27001 A.8.15 → 高性能异步审计与只读日志内核
第三方运维人员	数据窃取	投递	信息泄露 (I)	业务核心表数据	SQL注入 (T1190)	自主访问控制 (4.2)	高	SQL防火墙+静态脱敏；Oracle AVDF；PCI DSS 3.2 → 内核级AST白名单SQL防火墙
恶意内部员工	规避审计	安装	篡改 (T)	审计日志记录	日志清除 (T1070)	用户数据完整性 (4.6)	高	审计日志防篡改（只读表空间）；Oracle Blockchain Table；NIST AU-9 → 内核防篡改账本（Ledger Hash）
云租户（恶意邻居）	勒索	命令与控制	权限提升 (E)	存储过程/函数/包	服务器软件组件劫持 (T1505)	强制访问控制 (4.4)	中	最小权限+代码签名；Oracle Database Vault；NIST AC-6 → 强三权分立与Realm特权隔离
恶意应用程序	报复	目标达成	拒绝服务 (D)	物理备份集/快照	数据破坏 (T1485)	存储数据保密性 (4.7.1)	高	不可变备份+离线存储；Oracle RMAN；ISO 27001 A.8.13 → 备份加密与防删除兜底策略
恶意OS管理员	间谍活动	横向移动	信息泄露 (I)	数据库进程内存(SGA/PGA)	进程注入/内存刮削 (T1055/T1535)	用户数据保密性 (4.7.1)	高	机密计算(TEE/SGX)；Oracle Database 23ai Secure Enclaves；NIST SC-3 → 内存密态运算引擎
物理入侵者	误操作/物理破坏	物理访问	信息泄露 (I)	配置文件(spfile/pg_hba)	系统信息发现 (T1082)	可信路径 (4.8)	中	文件系统权限+配置加密；Oracle Data Safe；GB/T 20273 4.8；ISO 27001 A.8.1 → 内核可信路径与完整性校验
离职/僵尸账号	身份伪造	利用	欺骗 (S)	数据库链接(DBLink)	有效账户滥用 (T1078)	身份鉴别 (4.1)	中	账户生命周期管理；Oracle CMU；ISO 27001 A.8.2 → 动态权限回收与实时拦截
失陷的业务程序	数据泄露	渗出	信息泄露 (I)	敏感数据列（身份证/手机号）	通过API攻击 (T1559)	存储数据保密性 (4.7.1)	中	动态数据脱敏+行级安全；Oracle VPD/OLS；ISO 27001 A.8.26 → 列级加密(CLS)与行级安全(RLS)
内部运维人员	侦察	侦察	信息泄露 (I)	索引/分区/物化视图	网络嗅探 (T1040)	网络安全 (4.9)	低	加密通信+网络ACL；Oracle CMAN；GB/T 20273 4.9；ISO 27001 A.8.20 → 细粒度网络准入控制
供应链/第三方开发	权限提升	持久化	权限提升 (E)	触发器/UDF/扩展插件	创建账户 (T1136)	强制访问控制 (4.4)	高	权限分析+代码审查；Oracle Database Vault；NIST AC-6 → 插件签名验证与默认拒绝策略
内部恶意DBA	掩盖罪行	目标达成	篡改 (T)	Undo/Redo/WAL日志	禁用安全工具 (T1562)	用户数据完整性 (4.6)	高	防篡改日志+权限分析；Oracle Audit Vault；ISO 27001 A.8.15 → 写入只读日志流与篡改即报警
云租户（恶意）	权限提升	利用	欺骗 (S)	控制文件/密码文件	受信关系利用 (T1199)	身份鉴别 (4.1)	高	网络隔离+强认证；Oracle MFA；GB/T 20273 4.1；NIST IA-5 → 基于TEE的密钥保护
外部攻击者	勒索	利用	拒绝服务 (D)	数据库监听器/服务端口	服务停止 (T1489)	网络安全 (4.9)	中	端口隐藏+SQL防火墙；Oracle CMAN；ISO 27001 A.8.22 → 内核级连接限流与抗DDoS
网络中间人	数据窃取	利用	信息泄露 (I)	SSL证书私钥/Keystore	数据加密(自身通信) (T1573)	传输数据保密性 (4.7.2)	高	HSM/KMS保护私钥；Oracle Key Vault；NIST SC-12 → 两级密钥管理架构
内部恶意DBA	规避审计	安装	篡改 (T)	数据库参数(init.ora)	域策略修改 (T1484)	安全审计 (4.5)	高	配置基线检查+变更审计；Oracle AVDF；CIS 基线 → 参数修改自动回滚与告警
恶意内部员工	数据窃取	收集	信息泄露 (I)	临时表空间/临时文件	数据从本地拉取 (T1213)	存储数据保密性 (4.7.1)	中	全密态执行+临时文件加密；Always Encrypted；ISO 27001 A.8.24 → 全密态查询处理引擎
物理入侵者	数据窃取	渗出	信息泄露 (I)	数据快照/克隆副本	数据泄露 (T1213)	存储数据保密性 (4.7.1)	中	快照加密+访问审计；Oracle RMAN；ISO 27001 A.8.12 → 存储级加密与快照防激活
外部渗透测试者	侦察	侦察	信息泄露 (I)	数据库服务端口/监听器	端口扫描 (T1046)	网络安全 (4.9)	低	防火墙策略+IPS；Oracle CMAN；GB/T 20273 4.9 → 端口敲门与隐身技术

chatgpt

攻击者画像	攻击动机	攻击阶段	攻击类型	攻击目标	攻击技术	影响安全域（GB/T 20273）	风险等级	安全功能与标准映射
外部攻击者	数据窃取	侦察	机密性攻击	用户凭据	暴力破解（T1110）	身份鉴别（4.1）	高	身份认证；GB/T 20273 4.1；ISO 27001 A.9；ISO 15408 FIA
内部恶意DBA	数据篡改	权限提升	完整性攻击	会话令牌	中间人攻击（T1557）	传输数据保密性（4.8.2）	中	TLS双向认证；GB/T 20273 4.8.2；ISO 27001 A.13.2；NIST SC-8
内部开发人员	权限提升	执行	否认攻击	数据字典	账户操纵（T1098）	安全审计（4.6）	高	统一审计；GB/T 20273 4.6；ISO 27001 A.12.4；NIST AU-3
第三方运维人员	拒绝服务	利用	信息泄露攻击	用户表数据	SQL注入（T1190）	自主访问控制（4.2）	高	数据脱敏；GB/T 20273 4.2；PCI DSS 3.2
网络中间人	规避审计	安装	可用性攻击	审计日志	日志清除（T1070）	用户数据完整性（4.7）	高	审计日志防篡改；GB/T 20273 4.7；ISO 27001 A.12.4；NIST AU-9
云租户	勒索	命令与控制	权限提升攻击	存储过程/函数	服务器组件劫持（T1505）	强制访问控制（4.4）	中	最小权限原则；GB/T 20273 4.4；NIST AC-6
恶意应用程序	报复	目标达成	机密性攻击	备份集	数据加密防绕过（T1022）	存储数据保密性（4.8.1）	高	透明加密(TDE)；GB/T 20273 4.8.1；ISO 27001 A.10.1
恶意操作系统管理员	间谍活动	-	-	内存明文	进程注入（T1055）	标记（4.3）	高	机密计算(TEE)；NIST SC-3
物理入侵者	误操作	-	-	配置文件	系统信息发现（T1082）	可信路径（4.9）	中	网络ACL；GB/T 20273 4.9；ISO 27001 A.13.1
-	身份伪造	-	-	数据导出文件	数据破坏（T1485）	-	低	备份加密
-	会话劫持	-	-	数据库链接	服务停止（T1489）	-	-	SQL防火墙
-	-	-	-	索引/分区	通过API攻击（T1559）	-	-	行级安全(RLS)
-	-	-	-	物化视图	客户端连接劫持（T1184）	-	-	列级加密
-	-	-	-	同义词	网络嗅探（T1040）	-	-	三权分立
-	-	-	-	触发器等对象	创建账户（T1136）	-	-	密钥管理(KMS/HSM)
-	-	-	-	临时表空间	数据从本地拉取（T1213）	-	-	全密态执行
-	-	-	-	Undo日志	禁用安全工具（T1562）	-	-	权限分析工具
-	-	-	-	控制文件	受信关系利用（T1199）	-	-	-
-	-	-	-	监听器/端口	反向工程（T1598）	-	-	-
-	-	-	-	SSL证书私钥	数据加密（自身通讯）（T1573）	-	-	-
-	-	-	-	数据库参数	域策略修改（T1484）	-	-	-
-	-	-	-	数据库进程内存	-	-	-	-
-	-	-	-	数据快照	-	-	-	-
-	-	-	-	数据库服务端口	-	-	-	-

关系数据库安全威胁维度字典（多维去重 · 结构化版）

攻击者画像	攻击动机	攻击阶段	攻击类型	攻击目标	攻击技术	影响安全域（GB/T 20273 / ISO 15408）	风险等级	安全功能与标准映射
外部攻击者	数据窃取	侦察	机密性攻击	用户凭据	暴力破解（T1110）	身份鉴别（4.1）	高	身份认证 / MFA
内部恶意DBA	数据篡改	初始访问	完整性攻击	会话令牌	SQL注入（T1190）	自主访问控制（4.2）	中	访问控制（RBAC/RLS）
内部开发人员	权限提升	执行	可用性攻击	数据字典	中间人攻击（T1557）	标记（4.3）	低	三权分立
第三方运维人员	拒绝服务	持久化	不可否认性攻击	用户表数据	账户操纵（T1098）	强制访问控制（4.4）	-	最小权限
网络中间人	勒索	权限提升	-	索引/分区	日志清除（T1070）	安全审计（4.6）	-	审计日志防篡改
云租户	报复	防御规避	-	物化视图	进程注入（T1055）	用户数据完整性（4.7）	-	统一审计
恶意应用程序	间谍活动	凭据获取	-	同义词	服务器组件劫持（T1505）	存储数据保密性（4.8.1）	-	透明加密（TDE）
恶意操作系统管理员	规避审计	内部侦察	-	存储过程/函数	数据加密防绕过（T1022）	传输数据保密性（4.8.2）	-	TLS / 双向认证
物理入侵者	误操作	横向移动	-	触发器等对象	系统信息发现（T1082）	可信路径（4.9）	-	网络ACL
离职/僵尸账号	身份伪造	数据收集	-	临时表空间	通过API攻击（T1559）	FIA / FDP / FAU / FMT / FCS / FPT	-	SQL防火墙
自动化攻击工具	会话劫持	数据外传	-	Undo日志	客户端连接劫持（T1184）	-	-	行级安全（RLS）
-	-	影响/破坏	-	控制文件	创建账户（T1136）	-	-	列级安全（CLS）
-	-	-	-	监听器/端口	数据从本地拉取（T1213）	-	-	数据脱敏
-	-	-	-	SSL证书私钥	禁用安全工具（T1562）	-	-	密钥管理（KMS/HSM）
-	-	-	-	数据库参数	受信关系利用（T1199）	-	-	全密态执行
-	-	-	-	数据库进程内存	反向工程（T1598）	-	-	机密计算（TEE）
-	-	-	-	数据快照	数据加密（自身通讯）（T1573）	-	-	数据分类分级
-	-	-	-	数据库服务端口	-	-	-	配置基线检查

4.2 防御模型

一、访问安全

威胁ID	威胁描述	STRIDE	风险等级	缓解的安全功能
T-ACS-01	弱口令爆破或默认账户攻击	S	高	身份认证（密码策略、账户锁定、MFA）
T-ACS-02	重放攻击（抓取认证报文后重放）	S	中	身份认证（Challenge-Response、Kerberos时间戳）
T-ACS-03	从不可信IP或恶意主机连接	S/D	中	网络ACL（IP白名单）
T-ACS-04	SQL注入攻击绕过权限检查	E	高	SQL防火墙（SQL白名单）、最小权限原则
T-ACS-05	内部人员滥用合法权限（如DBA偷看数据）	I/E	高	访问控制（三权分立、行级安全）、数据脱敏
T-ACS-06	权限过度授予导致横向越权	E	高	访问控制（RBAC、最小权限）、权限分析工具
T-ACS-07	用户否认执行了某项敏感操作	R	高	安全审计（统一审计、细粒度审计）

二、传输安全

威胁ID	威胁描述	STRIDE	风险等级	缓解的安全功能
T-TRP-01	网络嗅探窃听数据库通信	I	高	安全传输（TLS 1.3、国密TLCP）
T-TRP-02	中间人攻击（MITM）篡改或劫持会话	T/S	高	安全传输（证书双向验证、防降级攻击）
T-TRP-03	会话劫持后模拟合法用户	S	高	安全传输（会话加密、绑定认证）

三、计算安全

威胁ID	威胁描述	STRIDE	风险等级	缓解的安全功能
T-CPT-01	数据库管理员或恶意进程在内存中读取敏感数据	I	高	全密态加密、机密计算（TEE）
T-CPT-02	通过侧信道攻击（如Cache时间）推断数据	I	中-高	机密计算（恒定时间执行）、全密态加密
T-CPT-03	SQL执行计划中泄露敏感值（如错误消息、执行计划）	I	中	数据脱敏（返回结果遮盖）、错误消息泛化
T-CPT-04	攻击者调用加密函数进行暴力破解或穷举	I/D	中	加密函数（密钥强度限制、防暴力调用策略）
T-CPT-05	云环境下虚拟机管理器直接读取数据库进程内存	I	高	机密计算（TEE内执行、加密内存）
T-CPT-06	已授权用户通过脱敏绕过机制看到原始数据	I	中	数据脱敏（权限校验、防绕过）

四、存储安全

威胁ID	威胁描述	STRIDE	风险等级	缓解的安全功能
T-STR-01	攻击者窃取磁盘或备份介质，绕过数据库直接读取数据文件	I	高	透明加密（TDE）、备份加密
T-STR-02	攻击者或恶意OS篡改数据文件中的数据块	T	高	数据防篡改（哈希链、账本表）、块级校验
T-STR-03	未授权用户通过文件系统直接拷贝数据文件	I	高	透明加密（TDE）+ 文件权限保护
T-STR-04	备份介质丢失导致数据泄露	I	高	透明加密（备份加密）
T-STR-05	密钥管理不当（硬编码、弱密钥、不轮换）导致加密失效	I/T	高	密钥管理（KMS、HSM、自动轮换）
T-STR-06	敏感数据未被识别（未分类分级）导致保护缺失	I	高	数据发现（自动扫描、分类分级）

五、合法合规

威胁ID	威胁描述	STRIDE	风险等级	缓解的安全功能
T-AUD-01	攻击者或恶意管理员删除/篡改审计日志以掩盖痕迹	T/R	高	审计日志防篡改（只写一次、WORM存储、加密）
T-AUD-02	审计日志被未授权读取（泄露用户行为）	I	中	审计日志加密存储、访问控制
T-AUD-03	审计数据量过大导致性能下降或日志溢出	D	中	统一审计（条件审计、采样审计）
T-AUD-04	合规性检查时无法证明对敏感数据的控制措施	R	高	合规对标（等保、ISO、GDPR）、审计记录完整性

4.3 安全功能

一、访问安全

身份认证、访问控制（自主访问控制、强制访问控制、角色访问控制（三权分立）、行级访问控制）

二、传输安全

SSL

三、计算安全

加密函数、全密态、机密计算、动态脱敏

四、存储安全

透明加密、防篡改

五、合法合规

安全审计、密钥管理

一、接入安全
1. 网络防火墙
- 不可信IP登录
2. 身份认证
暴力破解
凭证重放
默认账户攻击
过期账号攻击
弱口令攻击
内存凭证残留
认证耗尽
密码泄露
二、传输安全
3. 安全传输
数据泄露
流量伪造
流量重放
会话密钥泄露
证书伪造
身份伪造
三、访问安全
4. 访问控制
未授权访问
越权访问
权限提升
权限滥用
权限提升

海量 1 用例 oracle加密函数

Tue, 25 Feb 2025 15:31:00 +0800

CREATE SCHEMA pgcrypto_2_text;
SET search_path TO pgcrypto_2_text;

/* ------------------------------------------------------------------------------------------------
 * part 0: create some utils functions
 * ------------------------------------------------------------------------------------------------
 */
CREATE FUNCTION strtoraw(string VARCHAR2) RETURN RAW IS
BEGIN
RETURN utl_raw.cast_to_raw(string);
END;
/

CREATE FUNCTION rawtostr(rawdata RAW) RETURN VARCHAR2 IS
BEGIN
RETURN utl_raw.cast_to_varchar2(rawdata);
END;
/

-- get data type name
CREATE OR REPLACE FUNCTION oidgettype(typeoid OID)
RETURNS TEXT AS $$
BEGIN
 RETURN (SELECT typname FROM pg_type WHERE oid = typeoid);
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION oidgettype(typeoids OIDVECTOR)
RETURNS TEXT[] AS $$
DECLARE
 result TEXT[] := '{}';
 typoid OID;
 typename TEXT;
BEGIN
 FOREACH typoid IN ARRAY typeoids LOOP
 SELECT typname INTO typename
 FROM pg_type
 WHERE oid = typoid;
 result := array_append(result, COALESCE(typename, 'Unknown OID'));
 END LOOP;
 RETURN result;
END;
$$ LANGUAGE plpgsql;

-- find all functions from dbms_obfuscation_toolkit
CREATE VIEW allfuncs AS
SELECT proname name,pronargs args,oidgettype(prorettype) output,oidgettype(proargtypes) input
FROM pg_proc
WHERE pronamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'dbms_obfuscation_toolkit') ORDER BY 1,3,2;

/* ------------------------------------------------------------------------------------------------
 * part 1: install pgcrypt with different versions
 * ------------------------------------------------------------------------------------------------
 */
-- available version
SELECT * FROM pg_available_extension_versions WHERE name = 'pgcrypto';

-- 2.0 (default version)
CREATE EXTENSION pgcrypto;
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
SELECT * FROM allfuncs;
DROP EXTENSION pgcrypto;

-- 1.2 (old version)
CREATE EXTENSION pgcrypto WITH VERSION '1.2';
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
SELECT * FROM allfuncs;
DROP EXTENSION pgcrypto;

-- 2.0 --> 1.2
CREATE EXTENSION pgcrypto;
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
ALTER EXTENSION pgcrypto UPDATE TO '1.2';
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
SELECT * FROM allfuncs;
DROP EXTENSION pgcrypto;

-- 1.2 --> 2.0
CREATE EXTENSION pgcrypto WITH VERSION '1.2';
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
ALTER EXTENSION pgcrypto UPDATE TO '2.0';
SELECT * FROM pg_extension WHERE extname = 'pgcrypto';
SELECT * FROM allfuncs;
DROP EXTENSION pgcrypto;

/* ------------------------------------------------------------------------------------------------
 * part 2: core functions
 * ------------------------------------------------------------------------------------------------
 */
CREATE EXTENSION pgcrypto;

-- 1 desencrypt
SELECT dbms_obfuscation_toolkit.desencrypt(strtoraw('11111111'), strtoraw('11111111')) FROM dual;
SELECT dbms_obfuscation_toolkit.desencrypt(strtoraw('1111111111111111'), strtoraw('11111111')) FROM dual;

-- 2 desdecrypt
SELECT rawtostr(dbms_obfuscation_toolkit.desdecrypt(hextoraw('655EA628CF62585F'), strtoraw('11111111'))) FROM dual;
SELECT rawtostr(dbms_obfuscation_toolkit.desdecrypt(hextoraw('655EA628CF62585F20D3B8A6E657876B'), strtoraw('11111111'))) FROM dual;

-- 3 des3encrypt
SELECT dbms_obfuscation_toolkit.des3encrypt(strtoraw('11111111'), strtoraw('1111111122222222'), 0, strtoraw('11111111')) FROM dual;
SELECT dbms_obfuscation_toolkit.des3encrypt(strtoraw('1111111111111111'), strtoraw('1111111122222222'), 0, strtoraw('11111111')) FROM dual;

-- 4 des3decrypt
SELECT rawtostr(dbms_obfuscation_toolkit.des3decrypt(hextoraw('0D28E17571051319'), strtoraw('1111111122222222'), 0, strtoraw('11111111'))) FROM dual;
SELECT rawtostr(dbms_obfuscation_toolkit.des3decrypt(hextoraw('0D28E17571051319ACCE2D19D9AED5C8'), strtoraw('1111111122222222'), 0, strtoraw('11111111'))) FROM dual;

-- 5 des3encrypt -- without iv
SELECT dbms_obfuscation_toolkit.des3encrypt(strtoraw('11111111'), strtoraw('1111111122222222')) FROM dual;
SELECT dbms_obfuscation_toolkit.des3encrypt(strtoraw('1111111111111111'), strtoraw('1111111122222222')) FROM dual;

-- 6 des3decrypt -- without iv
SELECT rawtostr(dbms_obfuscation_toolkit.des3decrypt(hextoraw('7934131269E334A2'), strtoraw('1111111122222222'))) FROM dual;
SELECT rawtostr(dbms_obfuscation_toolkit.des3decrypt(hextoraw('7934131269E334A2BCC64878CC5A075A'), strtoraw('1111111122222222'))) FROM dual;

/* ------------------------------------------------------------------------------------------------
 * part 3: different args
 * ------------------------------------------------------------------------------------------------
 */
-- 1 des
CREATE TABLE tplain (id INT, plain TEXT, key TEXT);
INSERT INTO tplain VALUES
 (1, '', ''),
 (2, NULL, NULL),
 -- different plain
 (11, NULL, '88888888'),
 (12, '', '88888888'),
 (13, '1', '88888888'),
 (14, '7777777', '88888888'),
 (15, '88888888', '88888888'),
 (16, '999999999', '88888888'),
 (17, '17171717171717171', '88888888'),
 (18, '242424242424242422424242','88888888'),
 -- different key
 (31, '88888888', NULL),
 (32, '88888888', ''),
 (33, '88888888', '1'),
 (34, '88888888', '7777777'),
 (37, '88888888', '88888888'),
 (38, '88888888', '999999999'),
 (37, '88888888', '17171717171717171'),
 (38, '88888888', '242424242424242422424242');

CREATE TABLE tcipher (id INT, key TEXT, cipher RAW);
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 1;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 2;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 11;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 12;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 13;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 14;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 15;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 16;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 17;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 18;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 31;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 32;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 33;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 34;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 35;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 36;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 37;
INSERT INTO tcipher SELECT id, key, dbms_obfuscation_toolkit.desencrypt(strtoraw(plain), strtoraw(key)) FROM tplain WHERE id = 38;
SELECT id,cipher,length(cipher) FROM tcipher ORDER BY id;

SELECT id,rawtostr(dbms_obfuscation_toolkit.desdecrypt(cipher, strtoraw(key))) FROM tcipher ORDER BY id;

DROP TABLE tplain,tcipher;

-- 2 3des
CREATE TABLE tplain (id INT, plain TEXT, keymod INT, key TEXT, iv TEXT);
INSERT INTO tplain VALUES
 (1, '', 0, '', ''),
 (2, NULL, 0, NULL, NULL),
 -- different plain
 (11, NULL, 0, '1616161616161616', '88888888'),
 (12, '', 0, '1616161616161616', '88888888'),
 (13, '1', 0, '1616161616161616', '88888888'),
 (14, '7777777', 0, '1616161616161616', '88888888'),
 (15, '88888888', 0, '1616161616161616', '88888888'),
 (16, '999999999', 0, '1616161616161616', '88888888'),
 (17, '17171717171717171', 0, '1616161616161616', '88888888'),
 (18, '242424242424242422424242',0, '1616161616161616', '88888888'),
 -- different keymod
 (31, '1616161616161616', NULL, '1616161616161616', '88888888'),
 (32, '1616161616161616', -1, '1616161616161616', '88888888'),
 (33, '1616161616161616', -1.1, '1616161616161616', '88888888'),
 (34, '1616161616161616', 1.1, '1616161616161616', '88888888'),
 (35, '1616161616161616', 2, '1616161616161616', '88888888'),
 (36, '1616161616161616', '0', '1616161616161616', '88888888'),
 (37, '1616161616161616', 1, '242424242424242422424242', '88888888'),
 -- different key
 (51, '1616161616161616', 0, NULL, '88888888'),
 (52, '1616161616161616', 0, '', '88888888'),
 (53, '1616161616161616', 0, '1', '88888888'),
 (54, '1616161616161616', 0, '7777777', '88888888'),
 (55, '1616161616161616', 0, '88888888', '88888888'),
 (56, '1616161616161616', 0, '999999999', '88888888'),
 (57, '1616161616161616', 0, '17171717171717171', '88888888'),
 (58, '1616161616161616', 0, '242424242424242422424242', '88888888'),
 (59, '1616161616161616', 0, '272727272727272727272727272', '88888888'),
 (61, '1616161616161616', 1, NULL, '88888888'),
 (62, '1616161616161616', 1, '', '88888888'),
 (63, '1616161616161616', 1, '1', '88888888'),
 (64, '1616161616161616', 1, '7777777', '88888888'),
 (65, '1616161616161616', 1, '88888888', '88888888'),
 (66, '1616161616161616', 1, '999999999', '88888888'),
 (67, '1616161616161616', 1, '17171717171717171', '88888888'),
 (68, '1616161616161616', 1, '242424242424242422424242', '88888888'),
 (69, '1616161616161616', 1, '272727272727272727272727272', '88888888'),
 -- different iv
 (81, '1616161616161616', 1, '242424242424242422424242', NULL),
 (82, '1616161616161616', 1, '242424242424242422424242', ''),
 (83, '1616161616161616', 1, '242424242424242422424242', '1'),
 (84, '1616161616161616', 1, '242424242424242422424242', '7777777'),
 (85, '1616161616161616', 1, '242424242424242422424242', '88888888'),
 (86, '1616161616161616', 1, '242424242424242422424242', '999999999'),
 (87, '1616161616161616', 1, '242424242424242422424242', '17171717171717171'),
 (88, '1616161616161616', 1, '242424242424242422424242', '242424242424242422424242'),
 (89, '1616161616161616', 1, '242424242424242422424242', '272727272727272727272727272');

CREATE TABLE tcipher (id INT, CIPHER RAW, keymod INT, key TEXT, iv TEXT);
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 1;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 2;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 11;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 12;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 13;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 14;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 15;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 16;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 17;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 18;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 31;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 32;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 33;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 34;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 35;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 36;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 37;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 51;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 52;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 53;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 54;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 55;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 56;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 57;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 58;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 59;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 61;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 62;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 63;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 64;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 65;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 66;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 67;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 68;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 69;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 81;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 82;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 83;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 84;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 85;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 86;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 87;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 88;
INSERT INTO tcipher SELECT id, dbms_obfuscation_toolkit.des3encrypt(strtoraw(plain), strtoraw(key), keymod, strtoraw(iv)), keymod, key, iv FROM tplain WHERE id = 89;
SELECT * FROM tcipher;

SELECT id, rawtostr(dbms_obfuscation_toolkit.des3decrypt(cipher, strtoraw(key), keymod, strtoraw(iv))) FROM tcipher ORDER BY id;

DROP TABLE tplain, tcipher;

/* ------------------------------------------------------------------------------------------------
 * part 4: other functions
 * ------------------------------------------------------------------------------------------------
 */
SELECT length(dbms_obfuscation_toolkit.desgetkey(strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'))) FROM dual;
SELECT length(dbms_obfuscation_toolkit.des3getkey(0, strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'))) FROM dual;
SELECT length(dbms_obfuscation_toolkit.des3getkey(1, strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'))) FROM dual;
SELECT dbms_obfuscation_toolkit.md5(strtoraw('1111111111111111')) FROM dual;

CREATE TABLE deskey(id INT, key RAW);
CREATE TABLE des3key0 (id INT, key RAW);
CREATE TABLE des3key1 (id INT, key RAW);

INSERT INTO deskey SELECT generate_series(1, 1000),
 dbms_obfuscation_toolkit.desgetkey(strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'));
INSERT INTO des3key0 SELECT generate_series(1, 1000),
 dbms_obfuscation_toolkit.des3getkey(0, strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'));
INSERT INTO des3key1 SELECT generate_series(1, 1000),
 dbms_obfuscation_toolkit.des3getkey(1, strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'));

CREATE TABLE allcnt (cnt INT);
INSERT INTO allcnt SELECT count(*) FROM deskey GROUP BY key;
INSERT INTO allcnt SELECT count(*) FROM des3key0 GROUP BY key;
INSERT INTO allcnt SELECT count(*) FROM des3key1 GROUP BY key;
SELECT cnt,count(*) FROM allcnt GROUP BY cnt;

-- test (need to spend too much time)

-- CREATE TABLE moretime(id INT, key RAW);
-- INSERT INTO moretime SELECT generate_series(1, 100000),
-- dbms_obfuscation_toolkit.desgetkey(strtoraw('11111111112222222222333333333344444444445555555555666666666677777777778888888888'));
-- -- 预期 key列重复的字符不多
-- SELECT * FROM moretime ORDER BY key ASC LIMIT 10;
-- SELECT * FROM moretime ORDER BY key DESC LIMIT 10;
-- DROP TABLE moretime;

DROP TABLE deskey, des3key0, des3key1, allcnt;

DROP EXTENSION pgcrypto;
RESET search_path;
DROP SCHEMA pgcrypto_2_text CASCADE;

海量 1 设计 oracle加密函数

Tue, 25 Feb 2025 09:49:00 +0800

1

设置默认版本

contrib/pgcrypto/pgcrypto.control

defaultl_version = '2.0'
dbcompatibilities = 'A, B, PG'

生成同名的sql文件

touch contrib/pgcrypto/pgcrypto-2.0.sql

安装sql文件

# pgcrypto.control与pgcrypt.*.sql文件
ll $GAUSSHOME/share/postgresql/extension | grep pgcrypto

加载插件

# 执行：CREATE EXTENSION pgcrypto
 ..
 CreateExtension
 check_valild_extension_name # 检查插件名：要求不含 '-'、不含'..'等路径字符
 get_extension_oid
 heap_open('pg_extension')
 systable_beginscan # 遍历系统表 pg_extension：确保插件存在
 read_extension_control_file
 parse_extension_control_file
 get_extension_control_filename
 sprintf("{share}/extension/{extension_name}.control")
 ParreConfigFp
 # 获取 directory, default_version, module_pathname, dbcompatibilities 等参数
 get_extension_script_filename
 get_extension_script_direcotry
 if name is 'pgcrypto':
 sprintf("{script_dir}/crypto-a.sql")
 read_extension_script_file
 InsertExtensionTuple # 插入系统表 pg_extension
 execute_extension_script
 ApplyExtensionUpdates

海量 1 需求 oracle加密函数

Wed, 19 Feb 2025 16:20:00 +0800

1 简介

1.1 目的

早期版本的oracle提供一个包含多个加密函数的包，用户可通过SQL语法调用加密函数，实现数据加密功能。本文主要介绍以下几点：

oracle加密包的功能与使用方法
vastbase实现oracle加密包
vastbase加密包的功能与使用方法

本文档可指导开发者、测试者熟悉vastbase加密包特性的功能场景。

本文档的内容已被上传至tapd，tapd上，排版更好看，测试用例更方便复制。建议直接从tapd上查看本文档原文： https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007194

1.2 适用范围

vastbase 3.0.8及之后版本。

1.3 术语定义、首字母缩写词和缩略语

DES：Data Encryption Standard，数据加密标准，一种早期通用的加密算法
3DES：Triple DES，基于DES演进的一种早期通用的加密算法
MD5：Message-Digest Algorithm，一种早期通用的数据摘要算法

1.3 参考资料

oracle dbms_obfuscation_toolkit 函数介绍：https://docs.oracle.com/cd/A97630_01/appdev.920/a96590/adgsec04.htm
oracle dbms_obfuscation_toolkit 函数参数：https://docs.oracle.com/cd/B10500_01/appdev.920/a96612/d_obtoo2.htm
tapd上，本需求文档： https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007194
tapd上，本需求的测试用例： https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007197

2 支持oracle加密插件dbms_obfuscation_toolkit

2.1 功能简述

早期版本oracle提供7个内置加密函数。早在4年或更早之前的旧版本vastbase中，也提供7个与oracle一致的加密函数，这7个函数，函数名、函数入参与oracle一致，但是，6个函数输出、15个函数参数约束与oracle不一致，本特性将重构这些加密函数，确保函数的输出、约束等与oracle一致。

一、基础知识

加密的原理
加密算法有很多种，不同场景中，适合的加密算法类型不同。对存储数据加密，通常采用对称密码算法，此处主要介绍对称密码算法：
- 加密原理：输入1个明文，输入1个密钥，对明文和密钥进行一些可逆的运算（比如异或，代换），可得到1个密文。密钥通常是随机生成的
- 加密算法：DES算法，发布于1977年，已确定为不安全加密算法。3DES算法，调用3次DES算法，生成3个密钥，安全性与DES差别不大，也属于不安全的加密算法。AES算法，发布于2001年，通用的国际标准，替代不安全的DES算法

数据库加密函数
几乎所有数据库，都提供内置加密函数，让用户通过SQL语句调用。最典型的场景如下：

-- 假设，数据库提供函数encrypt(明文，密钥，加密算法)，输出为密文
-- 用户想表't1'中存储数据'shenkun'，则存储的语法如下：（用户自己保管密钥）
INSERT INTO t1 VALUES (encrypt('shenkun', '一串随机的密钥', 'aes'));

二、Oracle加密包

早期版本的oracle中，包含1个名为dbms_obfuscation_toolkit的包，提供7个函数，主要实现加密、解密等功能：

版本信息：oracle 8i版本开始提供，oracle 10g版本开始不被推荐使用，由dbms_crypto代替，oracle 21c版本正式移除
函数列表：
- 生成随机数：desgetkey(seed) -> key
- 加密：desencrypt(input, key) -> encrypted_data
- 解密：descdecrypt(input, key) -> decrypted_data
- 生成随机数：des3getkey(which=>0, seed) -> key
- 加密：des3encrypt(input, key, which=>0, iv=>012345678abcdef) -> encrypted_data
- 解密：des3decrypt(input, key, which=>0, iv=>012345678abcdef) -> decrypted_data
- 哈希：md5(input) -> checksum
函数参数：函数参数有2种数据类型：varchar2, raw。与raw类型相比，如果是varchar2类型，参数名需加上_string后缀。比如，raw类型的入参名为input，则varcha2类型入参名为input_string
函数限制：
- desgetkey：seed长度最短为80字节
- desencrypt：input长度是8字节的整数倍；key最短为8字节，超过8字节的部分被丢弃
- descdecrypt：input长度是8字节的整数倍；key最短为8字节，超过8字节的部分被丢弃
- des3getkey: seed长度最短为80字节
- des3encrypt：input长度是8字节的整数倍；which为0时，key最短为16字节，超过16字节的部分被丢弃；which为1时，key最短为24字节，超过24字节的部分被丢弃
- des3dencrypt：input长度是8字节的整数倍；which为0时，key最短为16字节，超过16字节的部分被丢弃；which为1时，key最短为24字节，超过24字节的部分被丢弃
- md5：无
参考文档
- 函数介绍：函数背景、注意事项等：https://docs.oracle.com/cd/A97630_01/appdev.920/a96590/adgsec04.htm
- 函数参数：参数类型、调用示例等：https://docs.oracle.com/cd/B10500_01/appdev.920/a96612/d_obtoo2.htm

以下是上述函数的调用示例：

数据结构与算法 1 总结

Tue, 21 Jan 2025 13:55:00 +0800

1 概述
1. 1.1 数据结构
  1. 数组
  2. 链表
  3. 二叉树
  4. 树
  5. 栈
  6. 队列
  7. 图
2. 1.2 算法
3. 问题
4. 1.2 解法
2 数组
参考

1 概述

1.1 数据结构

数组

排序
滑动窗口
去重
碰撞指针：回文串

链表

反转链表

二叉树

递归

树

b树：一个节点存多个值
- 降低树高度，结和IO机制，降低IO次数
b+树：只有叶子节点存数据
- 高效：中间节点不存数据，可存更多节点
- 稳定：查找次数一致
- 有序：叶子节点组成链表，方便批量查询
b-link树：节点指向右兄弟；每个节点存储High-key
- 并发：根据High-key，并发场景下，可判断节点是否发生分裂，无需加锁

栈

队列

图

1.2 算法

动态规划
- 功能：用表记录所有结果，避免重复计算（斐波那契、最长公共子序列）
- 问题
回溯：枚举 + 剪枝
分治
贪心

PostgreSQL 1-1 源码安装 (linux / macos)

Tue, 21 Jan 2025 13:55:00 +0800

摘要

本文介绍介绍如何在2种个人PC中，使用源码安装PostgreSQL，包括：

在Windows操作系统中，如何基于VwWare虚拟机，搭建Linux环境。并在Linux中，通过postgreSQL源码进行编译安装。

在MacOS操作系统中，如何使用云服务器中的Linux操作系统，搭建postgreSQL源码编译与学习环境。

1 在Windows中安装PostgreSQL
2 在MacOS中安装PostgreSQL

1 在Windows中安装PostgreSQL

1.1 目的

通过postgreSQL源码进行编译安装，主要目的是：

方便通过源码调试跟踪
直接修改以增加调试信息或新功能

1.2 准备

首先，介绍如何准备centOS虚拟机，并安装git、VSCode、gdb等工具

已有windows 10/11 x86物理机
window 10中，安装vmware
vmware中，安装centOS虚拟机

http://mirrors.huaweicloud.com/centos/8.4.2105/isos/x86_64/
centOS中，安装git，以及中文输入法
centOS中，安装VSCode

https://code.visualstudio.com/docs/setup/linux#_rhel-fedora-and-centos-based-distributions

centOS中，安装PostgresSQL依赖的第三方开源软件

sudo yum install -y readline readline-devel openssl openssl-devel zlib zlib-devel

# 但是，部分linux可能会裁剪应用，因此可能需要安装如下软件
sudo yum install -y bison bison-devel flex flex-devel

#[参考](https://blog.csdn.net/Linjingke32/article/details/80393576)

安装调试工具

传统安全 1 密码学

Tue, 21 Jan 2025 13:55:00 +0800

1 密码学综述

本文主要总结常见的密码算法与协议，并不详细介绍原理

密码算法
- 对称密码算法
- 非对称密码算法
- 哈希算法
- 完整性校验算法
其他算法
- 随机数生成算法
- 密钥派生算法

2 密码算法

2.1 对称加密算法

对称加密算法的基本原理是，输入明文、密钥，对明文进行分组，对每组明文进行多轮线性、非线性运算，比如异或、代换等，得到密文。
常见的对称加密算法如下：

算法	发布时间	分组长度	密钥长度	算法
DES	1977	64	64	16 x 置换（E扩展、异或、代换、P置换）
3DES	-	-	-	-
IDEA	1990	-	-	-
AES	2001	128	128/192/256	10/12/14 x 矩阵运算(字节代换、行移位、列混合、异或)
SM4	2012	128	128	32 x 分组运算（异或、代换、移位）
SM1	-	128	128	未公开
SM7	-	128	128	未公开

在实现加密的过程中，还有几个基础知识：

密钥扩展：加密时，会迭代很多轮，每一轮都用1个轮密钥。1个原始密钥，扩展为多个的轮密钥。

加密模式：一个原始明文，分为多个明文组，组与组之间的组合方式如下：

模式	中文	描述
ECB	电子密码本	不同的明文块，用相同的密钥
CBC	密码分组链接	上1密文块，与下一明文块异或
CTR	计数器模式	密钥加密计数器生成密钥流，密文块与密钥流异或
CFB	密码反馈模式	-
OFB	输出反馈模式	与CFB类似

常见算法的具体实现原理如下：

PostgreSQL 1-2 进程架构

Tue, 21 Jan 2025 13:55:00 +0800

1 进程架构
2 进程功能
1. 2.1 postgres线程
2. 1.3 进程通信
3 进程控制

1 进程架构

1.1 进程架构

postgresql 采用1+n+7的进程架构，包括：

1个postmaster进程
n个postgres进程
7个辅助进程：包括：
1. bg writer进程：
2. checkpointer进程：
3. walwriter进程：
4. autovacuum进程：
5. archiver进程：
6. statistics collector进程：
7. log collectoer进程：

进程架构图如下图所示：

1.2 进程启动

先启动postmaster进程，再由poastermaster启动n+7进程。
在postmaster主函数中，进程启动顺序如下：

main() # [主进程] 启动postmaster进程
 PostmasterMain()
 pqsignal(SIGUSR1, sigusr1_handler); # 注册信号
 SysLogger_Start() # [进程7] 启动log collector进程
 StartupDataBase() -> StartupProcessMain() # 进行故障恢复

 ServerLoop()
 BackendStartup()
 SysLogger_Start() # [进程n] 启动posters进程
 StartCheckpointer() -> CheckpointerMain() # [进程2] 启动heckpointer进程
 StartBackgroundWriter() -> BackgroundWriterMain() # [进程1] 启动bg writer进程
 StartWalWriter() -> InitXLOGAccess() WalWriterMain() # [进程3] 启动walwriter进程
 StartAutoVacLauncher() # [进程4] 启动autovacuum进程
 pgstat_start() # [进程6] 启动 statistics collector进程
 pgarch_start() # [进程5] 启动归档进程
 maybe_start_bgworker()

1.3 进程通信

2 进程功能

本章介绍各进程的主要功能。

PostgreSQL 1-3 执行模块

Tue, 21 Jan 2025 13:55:00 +0800

1 整体流程

1.1 执行流程

应用->驱动：通过驱动的api建立连接，并执行SQL语句
驱动->服务端：通过libpq协议封装SQL语句，发送至服务端
服务端 postgres线程：接收SQL语句，调用exec_siple_query()开始处理SQL语句

SQL引擎

解析器：通过flex进行词法解析，通过yacc进行语法分析，生成解析树
分析器：对解析树进行语义分析：包括检查表是否存在等，生成查询树
重写器：
计划期：根据查询树生成执行计划

执行器：自顶向下执行各个算子，执行过程中会调用存储引擎统一接口

INSERT / UPDATE / DELETE

ExecModifyTable 算子：EexecInsert / ExecUpdate / ExecDelete
 EexecInsert
 ExecMaterializeSlot
 ExecBRInsertTriggers /* ROW INSERT 触发器 */
 ExecWithCheckOptions /* 检查约束 */
 heap_insert /* 存储引擎统一接口 */
 ExecInsertIndexTuples
 ExecARInsertTriggers /* AFTER ROW 触发器 */
 ExecProcessReturning

SELECT

ExecIndexScan
 IndexNext()
 index_getnext()
 tid = index_getnext_tid(scan)
 index_fetch_heap(scan)
 heap_hot_search_buffer()
 PageGetItem()

传统安全 3 网络安全

Tue, 21 Jan 2025 13:55:00 +0800

网络欺骗 - 50%

概述：局域网内，结合数据传播特点，伪造数据，欺骗机器网卡
模型：
- 主机：维护ARP缓存，内容为 [IP:MAC]
- 协议：ARP：Address Resolution Protol：根据IP获取MAC
- 主机网卡：
  - 网卡工作模式：
    - 混杂：接收所有数据
    - 广播：接收dest_addr为广播地址的数据
    - 多播：接收dest_addr为多播地址的数据
    - 单播：接收dest_addr为本机地址的数据
    - 链路层：需要MAC地址
- 交换机
  - 分类：二层、三层、四层交换机
  - 二层交换机：根据MAC，找到端口，发送数据，维护MAC缓存，内容为 [MAC:端口]
- 示意图
```
 帧[mac][ip] 帧[mac][ip]
 [主机1] -----------> [交换机] -------------> [主机2]
| IP | MAC | | 端口 | MAC |
| IP | MAC | | 端口 | MAC |
```
攻击方式：
- 1 攻击机：发送大量虚假MAC 的帧，占满交换机缓存，让交换机广播数据
- 2 攻击机：发送虚假的ARP：欺骗局域网内的主机
- 3 受害机：把数据发到错误的地方，比如攻击机
解决：
- 预防：主机静态ARP表、进制ARP
- 检测：看某台主机的ARP缓存，判断是否有主机发送大量ARP包
- 检测：看无通信主机的ARP缓存，检测是否缓存了ARP包

信息收集 - ok

概述：在进行攻击之前，收集受害者的信息
攻击方式：
- 主机状态
  1. ICMP Echo攻击：发送ICMP Echo包，如果回复，则主机开启
  2. Non-Echo ICMP：发送其他类型的ICMP包，如果回复，则主机开启
  3. IP异常包头：发送异常IP包（无效字段、错误分片、静止分片），判断主机返回信息
  4. TCP扫描
  5. UDP扫描
- 操作系统版本
  1. 被动栈指纹识别：嗅探，收集网络中数据包，判断IP的TTL、TOS、DF和TCP 的Windows-size等特征
  2. 主动栈指纹识别：TCP三次握手，ACK序号相等还是加一
  3. TCP ISN取样：向目标主机多次握手，多次取样返回的ISN
  4. ICMP包错误信息发送速率：向目标主机连续发送大量icmp错误包
  5. ICP消息引用：向目标主机发送ICMP错误包，判断返回的错误引用长度
- 端口
  1. TCP 连接（开放）：tcp三次握手后，tcp反向ident协议可查看：对方进程pid和角色
  2. TCP SYN（半开放）：发送tcp syn包，端口关闭：返回rst，开启：返回syn+ack
  3. TCP FIN（隐蔽）：发送fin包，关闭：返回rst，开启：无返回
  4. TCP Xmax（隐蔽）：发送fin、urg、push标记的包，关闭：返回rst，开启：返回
  5. TCP NULL （隐蔽）：发送关闭无标记包
  6. FTP PROXY （隐藏）：请求ftp服务向目标主机建立连接
  7. UDP：发送UDP包，关闭：ICMP port unreachable，开启：无返回
- 软件版本
- 漏洞
  1. 操作系统漏洞：基于漏洞库，扫描CGI漏洞、POP3漏洞、FTP漏洞、SSH漏洞等

拒绝服务 - ok

概述：合法用户无法访问服务

PostgreSQL 1-4 存储模块

Tue, 21 Jan 2025 13:55:00 +0800

摘要

本博客以循序渐进的方式，依次简要介绍PostgreSQL存储模块的各个子模块的基础功能，提及内容适合数据库内核初学者。本博客旨在介绍核心原理，以便于理解为首，部分内容可能不会100%准确与具体，针对每个提及的子模块，之后会分别单独写博客详细介绍

1 概述

1.1 PostgreSQL的使用流程

本博客仅讨论存储模块的关键原理。简而言之，PostgreSQL将数据合理地组织并存储在磁盘上，并向用户提供SQL接口，让其读写磁盘上的指定数据。以下是PostgreSQL简单工作流程：

传统安全 4 防火墙

Tue, 21 Jan 2025 13:55:00 +0800

1 netfilter

1.1 netfilter 架构

1.2 netfilter 编程

struct nf_hook_state {
 unsigned int hook;
 int thresh;
 u_int8_t pf;
 struct net_device *in;
 struct net_device *out;
 struct sock *sk;
 struct net *net;
 struct list_head *hook_list;
 int (*okfn)(struct net *, struct sock *, struct sk_buff *);
};

/* 回调函数 */
typedef unsigned int nf_hookfn(
 void *priv,
 struct sk_buff *skb,
 const struct nf_hook_state *state);

/* 回调函数返回值 */
#define NF_DROP 0
#define NF_ACCEPT 1
#define NF_STOLEN 2
#define NF_QUEUE 3
#define NF_REPEAT 4
#define NF_STOP 5

/* 向内核注册回调函数 */
struct nf_hook_ops {
 struct list_head list; /* 链表成员 */
 nf_hookfn *hook; /* 回调函数 */
 struct module *owner;
 int pf; /* 协议簇 */
 int hooknum; /* NF_ARP_IN, NF_ARP_OUT */
 int priority; /* 优先级 */
} ;

/* 协议簇 */
#define AF_UNSPEC 0
#define AF_UNIX 1
#define AF_LOCAL 1
#define AF_INET 2 /* IP */
#define AF_INET6 10 /* IPV6 */
#define AF_LLC 26

/* 注册 */
void nf_register_hooks(struct nf_hook_ops *ops_arr, int arr_len);

module_init(arp_hook_init)

参考：netfilter结构体：https://www.cnblogs.com/ink-white/p/16818769.html
参考：netfilter构造报文：https://www.cnblogs.com/ink-white/p/16816464.html
参考：netfilter捕获arp：https://blog.csdn.net/fuyuande/article/details/79772134

2 iptables

2.1 iptables 命令

# 1 查看所有规则
iptables --list -n
iptables --list -t [filter/mangle/nat/raw]

# 2 规则管理
iptables [操作] [链名] [动作] [过滤条件]
 # 操作
 -A : 新增规则，添加至末尾
 -I : 新增规则，添加到指定位置
 -D : 删除规则
 -R : 替换规则
 # 链名
 PREROUTING
 INPUT
 OUTPT
 FORWARD
 # 动作
 -j ACCEPT
 -j DROP
 -j REJECT
 -j SNAT
 # 过滤条件
 -s 0.0.0.0 : 源IP
 -sport 100 : 源端口
 -d 1.1.1.1 : 目标IP
 -dport 100 : 目标端口
 -p icmp/tcp/udp : 协议类型
 -p icmp --icmp-type 8 : ping
 -i etho : 数据接收网口
 -o eth1 : 数据发送网口
 -m 其他参数
 -m mac --mac-source 00:00:00:00:01
 -m owner --uid-owner 100
 -m owner --pid-owner 100
 -m state --state [NEW, RELATED, ESTABLISHED, INVALID]

# 3 启动与停止 [ location: /etc/init.d/iptables ]
iptables start
iptables stop
iptables restart

# 4 批量操作
iptables -F # 清空规则
iptables -X # 清空用户规则
iptables -Z # 清空计数

# 5 保存规则 [ storage: /etc/sysconfig/iptables ]
iptables save

3 kkwall

3.1 命令

# 1 过滤
# 1.1 过滤ip
kkwall filter -sip 10.10.10.10
kkwall accept -dip 10.10.10.10

# 1.2 过滤端口
kkwall filter -sport 100
kkwall accept -dport 100
kkwall filter -dport all

# 1.2 过滤协议
kkwal filter -protol tcp/icmp/udp/igmp

# 3 入侵检测
# 3.1 防 arp 欺骗
 # 网关固定mac
kkwal set mac 0.0.0.0/00:00:00:00:01
 # 短时间内，大量arp报文

# 3.2 端口扫描
 # 设置端口白名单，如果报文目标端口在白名单外的端口，为异常报文
kkwal set ports 22,80
 # 检测所有tcp状态，识别所有syn和fin扫描

# 3.3 拒绝服务
 # 系统漏洞：
 # ping of death: 超长icmp包 63336， 分片发送 -> 丢弃
 # tear drop: 重复的IP分片 -> 丢弃
 # 有限资源
 # smurf: 短时间接收到大量icmp echo包 -> 全丢弃
 # tcp syn flood: 短时间，大量半开请求
 # tcp syn land: tcp src_addr和dst_addr都是自己
 # http flood: http请求

typedef struct {
 ;
} ArpHdr;

typedef struct {
 ;
} IpHdr;

typedef struct {
 ;
} TcpHdr;

typedef struct {
 int type;
 IpHdr *iphdr;
 TcpHdr *tcphdr;
} Fragment;

/* */
void detecte_trick(ArpHdr *arp)
{
 ArpItem staticarp = arp_list_find(arp->mac);
 if (arp->dst_ip != staticarp) {
 printf("arp trick");
 }
}

参考：iptables常用命令 https://blog.csdn.net/shiner_chen/article/details/132104300

PostgreSQL 1-5 initdb

Wed, 26 Feb 2025 18:14:00 +0800

initdb 流程

opengauss

main # initdb.cpp
 canonicalize_path # PGDATA
 find_other_exec # 在gs_initdb bin目录下，查找gaussdb bin
 # 在$GAUSSHOME/share/postgrsql目录下，检查以下文件是否存在
 check_input('postgres.bki, postgres.description, pg_hba.conf.sample, postgresql.conf.sample, ..., system_views.sql, ...')
 check_locale_encoding
 init_log
 gs_getenv_r('GAUSSLOG')
 write_version_file
 canonicalize_path('$PGDATA/PG_VERSION')
 fprintf(PG_MAJORVERSION = '9.2')
 setup_config
 readfile('$GAUSSHOME/share/postgrsql/postgresql.conf.sample')
 sprintf_s('$PGDATA/postgresql.conf')
 writefile('$PGDATA/postgresql.conf')
 InitUndoSubsystemMeta

 bootstrap_template1
 write_version_file
 setup_auth
 get_set_pwd
 setup_depend
 load_plpgsql
 setup_sysviews
 setup_description
 ...
 setup_privileges
 setup_schema
 setup_update
 vacuum_db
 make_template0
 make_postgres

传统安全 5 数据库加密

Tue, 21 Jan 2025 13:55:00 +0800

1 数据库加密的背景

1.1 数据库安全机制

应用将数据发送给数据库后，数据库组织数据，将数据存储在文件中，并提供一系列安全机制，保护数据安全。比如：

安全传输：基于TLS等安全协议，保证数据在应用与数据库之间传输的机密性、完整性等，避免攻击者对传输中的数据进行窃听、伪造、篡改等
身份认证：基于IP、口令、证书等鉴别用户身份，避免攻击者非法访问数据库
访问控制：通过多种访问控制机制，限制攻击者对数据库对象的的访问范围
安全审计：记录攻击者在数据库中执行的各项操作
数据脱敏：对隐私数据库进行脱敏处理，避免攻击者查看数据库中的隐私数据
数据防篡改：基于区块链等技术，记录数据变化情况，识别攻击者非法篡改磁盘上的数据库文件

1.2 数据泄露问题

在很多针对数据库的攻击行为中，攻击者可绕过上述数据库安全机制，直接从磁盘窃取数据，造成数据泄露问题。
为了规避此类问题，有效的方案是对数据进行加密，使攻击者仅能从磁盘获取数据密文，无法解密数据，从而解决数据泄露问题。

1.3 数据库加密方案分类

数据库加密方案较多，本博客仅介绍一些常见的，且适用于大部分场景的加密方案。

一、按加密位置分类

首先，按加密位置分类，可分为以下6种：

各方案的基本原理如下：

应用加密：应用先将数据加密，再使用SQL语句，将数据密文存储至数据库
全密态加密：数据库驱动识别并加密SQL语法中的数据，同时自动解密SQL查询结果。部分数据库产品提供此功能
网关或代理加密：在应用与数据库之间的中继节点中，比如代理或网关中，通过解析网络流量，自动识别与加解密流量中的数据，包括SQL语法中的数据与SQL查询结果。很多云服务、安全厂商提供此服务
加密函数：数据库内置加密函数或存储过程，应用可通过SQL语法主动调用加密函数。大部分数据库产品提供此功能
透明加密：数据库将数据存储至磁盘前，自动加密数据，数据库从磁盘读取数据时，自动解密数据。大部分数据库产品提供此功能
磁盘加密：操作系统处理磁盘读写请求时，自动加密与解密读写到的数据。部分操作系统或云存储服务提供此功能

二、按加密定义方式分类

上述加密方案中，按应用是否主动感知加密过程，可将其分为非自动加密与自动加密。

非自动加密
以应用加密为例，用户加密数据的流程如下：

-- 1 首先，定义表
CREATE TABLE t1 (c1 TEXT, c2 TEXT);
-- 2 假设需向t1中存储数据 (1, 'data1')，应用需要先将数据加密，在通过SQL语法将加密后的数据存储至数据库
-- 3 存储数据
INSERT INTO t1 VALUES ('encrypted[1]', 'encrypted[data1]');
-- 4 查询数据时，查询结果为数据密文，数据无法直接使用
SELECT * FROM t1; -- 查询结果为：('encrypted[1]', 'encrypted[data1]')
-- 5 应用需自行解密查询结果，最终解密后得到原始数据 (1, 'data1')

此类加密方案中，每次涉及数据读写操作时，都需要主动进行加密与解密，操作复杂。

海量 2 博客 profile

Thu, 22 May 2025 10:00:00 +0800

摘要：本文主要分为3个章节：

介绍Vastbase基于密码的身份认证机制，介绍密码相关配置参数，指出当前控制参数的局限性，提出PROFILE功能支持细粒度设置密码相关配置参数。

介绍Vastbase的PROFILE功能如何使用，包括管理PROFILE功能、管理PROFILE参数、管理用户PROFILE

介绍Vastbase身份认证流程与原理，介绍PROFILE功能的实现原理

1 PROFILE 功能背景
2 PROFILE 功能使用
3 PROFILE 功能原理
1. 3.1 身份认证元数据
2. 3.2 身份认证流程

1 PROFILE 功能背景

1.1 身份认证机制

Vastbase身份认证模块，主要采用基于密码的认证机制，常用的密码操作包括：

创建密码
创建新用户时，需指定密码。语法示例如下：
```
CREATE USER u1 PASSWORD 'u1.password';
```
Vastbase接收密码后，计算密码的哈希值，并将密码哈希值、密码创建时间等存储至系统表中。
使用密码
用户连接Vastbase时，需提供密码，使用vsql连接的命令如下：
```
vsql -h {host} -p {port} -U u1 -W 'u1.password' -d vastbase -r
```
Vastbase会与vsql进行身份认证交互，基于存储的密码哈希值，校验密码是否正确。同时，Vastbase还会进行其他检查，比如：密码是否过期、密码错误次数是否过多等。
修改密码
用户修改密码时，语法示例如下：

海量 2 用例 profile

Fri, 14 Mar 2025 16:14:00 +0800

1 CREATE/ALTER/DROP PROFILE
2 CREATE/ALTER USER .. PROFILE
3 验证profile生效
3 view

CREATE PROFILE pro1 limit password_reuse_time 0.00002 password_reuse_max 10; -- 1.72s
CREATE USER u1 PASSWORD 'u1.pass1' PROFILE pro1;
ALTER USER u1 PASSWORD 'u1.pass2';
ALTER USER u1 PASSWORD 'u1.pass1'; -- error, interval < password_reuse_time
\! sleep 2
ALTER USER u1 PASSWORD 'u1.pass1'; -- succeed, interval > password_reuse_time

ALTER PROFILE pro1 LIMIT password_reuse_time 0.00005; -- 4.32s
ALTER USER u1 PASSWORD 'u1.pass3';
ALTER USER u1 PASSWORD 'u1.pass4';
ALTER USER u1 PASSWORD 'u1.pass3'; -- error, interval < password_reuse_time
\! sleep 5
ALTER USER u1 PASSWORD 'u1.pass3'; -- succeed, interval > password_reuse_time

1 CREATE/ALTER/DROP PROFILE

-- check profile feature
SHOW resource_limit;

-- ================================ part 1 ================================
-- create profile
CREATE PROFILE pro1;
-- succeed: can set setting
CREATE PROFILE pro2 LIMIT failed_login_attempts 10;
-- succeed: can set more settings
CREATE PROFILE pro3 LIMIT
 failed_login_attempts 10 password_lock_time 20
 password_life_time 30 password_grace_time 40
 password_reuse_time 50 password_reuse_max 60
 idle_time 80;
-- succeed: repeated settings are allowed
CREATE PROFILE pro4 LIMIT password_life_time 10 password_life_time 20.2;
-- succeed: setting value could be 'unlimited'
CREATE PROFILE pro5 LIMIT failed_login_attempts unlimited password_lock_time 10 password_life_time unlimited;

-- succeed: name max len is 64, name will be truncated
CREATE PROFILE aaaaa111111111122222222223333333333444444444455555555556666666666; -- too long, max 64, wi
-- truncated name: aaaaa1111111111222222222233333333334444444444555555555566666666

SELECT profile,count(*) FROM vb_profiles GROUP BY profile ORDER BY profile;
SELECT * FROM vb_profiles WHERE profile = 'pro5' ORDER BY setname;

-- error: profile name is invalid
CREATE PROFILE 1; -- int
CREATE PROFILE 1.1; -- numeric

-- error: profile already exists
CREATE PROFILE default LIMIT failed_login_attempts 10;
CREATE PROFILE pro1 LIMIT failed_login_attempts 10;

/*
error: setting is invalid, supported settings:
 unit type min max
 ------------------------+---------+----------+---------+------------+----
 failed_login_attempts | times | int | 1 | 2147483646 | 10
 password_lock_time | days | double | 0.00001 | 24855 | 1
 password_life_time | days | double | 0.00001 | 24855 | 180
 password_grace_time | days | double | 0.00001 | 24855 | 7
 password_reuse_time | days | double | 0.00001 | 24855 | 1
 password_reuse_max | times | int | 1 | 2147483646 | 1
 idle_time | minutes | double | 0.00001 | 2147483646 | 10
*/
CREATE PROFILE epro2 LIMIT data_directory anyvalue;
CREATE PROFILE epro3 LIMIT password_effect_time 10;
CREATE PROFILE epro4 LIMIT 10 failed_login_attempts;

-- error: setting lose value
CREATE PROFILE epro5 LIMIT failed_login_attempts;
CREATE PROFILE epro6 LIMIT failed_login_attempts 10 password_lock_time;

-- error: setting value type is invalud
CREATE PROFILE epro7 LIMIT failed_login_attempts 'iamstring';
CREATE PROFILE epro8 LIMIT failed_login_attempts 1.1;
CREATE PROFILE epro9 LIMIT failed_login_attempts noint;
CREATE PROFILE epro10 LIMIT failed_login_attempts default;

-- error: setting value is out of limit
CREATE PROFILE epro11 LIMIT failed_login_attempts 0;
CREATE PROFILE epro12 LIMIT failed_login_attempts 1 password_lock_time 0;
CREATE PROFILE epro13 LIMIT password_lock_time 24856;
CREATE PROFILE epro14 LIMIT password_lock_time 0.000001;

SELECT profile,count(*) FROM vb_profiles GROUP BY profile ORDER BY profile;

DROP PROFILE pro1, pro2, pro3, pro4, pro5;
DROP PROFILE aaaaa111111111122222222223333333333444444444455555555556666666666;

-- ================================ part 2 ================================
-- alter profile
CREATE PROFILE pro1;
CREATE PROFILE pro2 LIMIT failed_login_attempts 100;
CREATE PROFILE pro3 LIMIT password_lock_time 20;

-- succeed: can set setting
ALTER PROFILE pro1 LIMIT failed_login_attempts 1000;
-- succeed: can set more settings
ALTER PROFILE pro2 LIMIT
 failed_login_attempts 10 password_lock_time 20
 password_life_time 30 password_grace_time 40
 password_reuse_time 50 password_reuse_max 60
 idle_time 80;
-- succeed: setting value could be 'unlimited'
ALTER PROFILE pro3 LIMIT failed_login_attempts unlimited password_lock_time 10 password_life_time unlimited;
-- succeed: can alter default profile
ALTER PROFILE default LIMIT failed_login_attempts 80 password_reuse_time 70.3;
SELECT * FROM vb_profiles ORDER BY profile,setname;

-- error: profile name is invalid
ALTER PROFILE 1 LIMIT failed_login_attempts 10; -- int
ALTER PROFILE 1.1 LIMIT failed_login_attempts 10; -- numeric
ALTER PROFILE aaaaa111111111122222222223333333333444444444455555555556666666666 LIMIT failed_login_attempts 10; -- too long, max 64

-- error: repeated settings are not allowed
ALTER PROFILE pro3 LIMIT password_reuse_time 10 password_reuse_time 20.2;

-- error: profile doesn't exist
ALTER PROFILE epro1 LIMIT failed_login_attempts 10;
ALTER PROFILE epro2 LIMIT failed_login_attempts 10;

/*
error: setting is invalid
*/
ALTER PROFILE pro1 LIMIT data_directory anyvalue;
ALTER PROFILE pro1 LIMIT password_effect_time 10;
ALTER PROFILE pro1 LIMIT 10 failed_login_attempts;

-- error: setting lose value
ALTER PROFILE pro1 LIMIT failed_login_attempts;
ALTER PROFILE pro1 LIMIT failed_login_attempts 10 password_lock_time;

-- error: setting value type is invalud
ALTER PROFILE pro1 LIMIT failed_login_attempts 'iamstring';
ALTER PROFILE pro1 LIMIT failed_login_attempts 1.1;
ALTER PROFILE pro1 LIMIT failed_login_attempts noint;
ALTER PROFILE pro1 LIMIT failed_login_attempts default;

-- error: setting value is out of limit
ALTER PROFILE pro1 LIMIT failed_login_attempts 0;
ALTER PROFILE pro1 LIMIT failed_login_attempts 1 password_lock_time 0;
ALTER PROFILE pro1 LIMIT password_lock_time 24856;
ALTER PROFILE pro1 LIMIT password_lock_time 0.000001;

DROP PROFILE pro1, pro2, pro3;

-- ================================ part 3 ================================
-- drop profile
CREATE PROFILE pro1;
CREATE PROFILE pro2 LIMIT failed_login_attempts 100;
CREATE PROFILE pro3 LIMIT password_lock_time 20;
CREATE PROFILE pro4;
CREATE PROFILE pro5;

-- succeed: drop profile
DROP PROFILE pro1;
DROP PROFILE IF EXISTS pro1;
DROP PROFILE IF EXISTS pro1, pro2, pro3;

SELECT profile,count(*) FROM vb_profiles GROUP BY profile;

-- error: profile doesn't exist
DROP PROFILE pro0;
DROP PROFILE pro1, pro4, pro5;

-- error: default profile can't be dropped
DROP PROFILE default;
DROP PROFILE pro4, default;

DROP PROFILE IF EXISTS pro4, pro5;

2 CREATE/ALTER USER .. PROFILE

-- ================================ part 4 ================================
-- set profile for user
SELECT * FROM vb_user_profiles;

CREATE PROFILE pro1;
CREATE PROFILE pro2;

-- succeed: set profile for user
CREATE USER u1 PASSWORD 'u1.pass1' PROFILE pro1;
CREATE USER u2 PASSWORD 'u2.pass1' PROFILE pro1;
CREATE USER u3 PASSWORD 'u3.pass1' PROFILE default;
CREATE USER u4 PASSWORD 'u4.pass1';

-- error: profile doesn't exist
CREATE USER eu1 PASSWORD 'u4.pass1' PROFILE pro1000;

-- error: profile name invalid
CREATE USER eu2 PASSWORD 'u4.pass1' PROFILE 1;
CREATE USER eu3 PASSWORD 'u4.pass1' PROFILE;

SELECT * FROM vb_user_profiles;

DROP USER IF EXISTS u1, u2, u3, u4;
-- catalog also changed
SELECT * FROM vb_user_profiles;

DROP PROFILE IF EXISTS pro1, pro2;

-- ================================ part 5 ================================
-- alter user profile
CREATE PROFILE pro1;
CREATE PROFILE pro2;
CREATE USER u1 PASSWORD 'u1.pass1';
CREATE USER u2 PASSWORD 'u2.pass1' PROFILE pro2;
CREATE USER u3 PASSWORD 'u3.pass1' PROFILE default;

-- succeed: alter user set profile
ALTER USER u1 PROFILE pro1;
ALTER USER u2 PROFILE default;
ALTER USER u3 PROFILE pro1;

-- error: profile doesn't exist
ALTER USER u1 PROFILE pro1000;

-- error: profile name invalid
ALTER USER u1 PROFILE 1;
ALTER USER u1 PROFILE;

SELECT * FROM vb_user_profiles ORDER BY roloid;

DROP USER IF EXISTS u1, u2, u3;
DROP PROFILE IF EXISTS pro1, pro2;

-- ================================ part 6 ================================
-- drop user and profile
CREATE PROFILE pro1;
CREATE PROFILE pro2;
CREATE PROFILE pro3;
CREATE USER u1 PASSWORD 'u1.pass1' PROFILE pro1;
CREATE USER u2 PASSWORD 'u2.pass1' PROFILE pro2;

-- succeed: drop user
SELECT * FROM vb_user_profiles WHERE rolname = 'u1';
DROP USER u1;
SELECT * FROM vb_user_profiles WHERE rolname = 'u1';

-- error: can't drop profile if any user are using it
DROP PROFILE pro2;

-- error: default profile can't be dropped
DROP PROFILE default;
DROP PROFILE pro3, default;
DROP PROFILE default, pro3;

SELECT * FROM vb_user_profiles ORDER BY roloid;

DROP USER IF EXISTS u1, u2;
DROP PROFILE IF EXISTS pro1, pro2, pro3;

3 验证profile生效

验证 failed_login_attempts 与 password_lock_time

CREATE PROFILE pro1 LIMIT
 failed_login_attempts 3
 password_lock_time 0.0001;
CREATE USER u1 PASSWORD 'u1.pass1' PROFILE pro1; -- 运行登录失败3次，失败后锁定8秒
CREATE USER u2 PASSWORD 'u2.pass1'; -- 允许登录失败无数次

vsql -p 5432 -d postgres -U u1 -W "u1.error1" -c "SELECT 1;"
vsql -p 5432 -d postgres -U u1 -W "u1.error1" -c "SELECT 1;"
vsql -p 5432 -d postgres -U u1 -W "u1.error1" -c "SELECT 1;"
vsql -p 5432 -d postgres -U u1 -W "u1.pass1" -c "SELECT 1;"
-- sleep 8s
vsql -p 5432 -d postgres -U u1 -W "u1.pass1" -c "SELECT 1;"

-- u2
vsql -p 5432 -d postgres -U u2 -W "u2.error1" -c "SELECT 1;"
vsql -p 5432 -d postgres -U u2 -W "u2.error1" -c "SELECT 1;"
vsql -p 5432 -d postgres -U u2 -W "u2.error1" -c "SELECT 1;"
vsql -p 5432 -d postgres -U u2 -W "u2.pass1" -c "SELECT 1;"
-- sleep 8s
vsql -p 5432 -d postgres -U u2 -W "u2.pass1" -c "SELECT 1;"

vsql -p 5432 -d postgres -c "DROP USER u1,u2"

验证 password_life_time 与 password_grace_time

CREATE PROFILE pro2 LIMIT
 password_life_time 0.0001 -- 8s
 password_grace_time 0.0001;

CREATE USER u1 PASSWORD 'u1.pass1' PROFILE pro2; -- 密码有效期为8s，密码宽容期也为8s
CREATE USER u2 PASSWORD 'u2.pass1'; -- 密码有效期无限制
\q

vsql -p 5432 -d postgres -U u1 -W "u1.pass1" -c "SELECT 1;"
-- sleep 8s
vsql -p 5432 -d postgres -U u1 -W "u1.pass1" -c "SELECT 1;"
-- sleep 8s
vsql -p 5432 -d postgres -U u1 -W "u1.pass1" -c "SELECT 1;"

vsql -p 5432 -d postgres -U u2 -W "u2.pass1" -c "SELECT 1;"
-- sleep 8s
vsql -p 5432 -d postgres -U u2 -W "u2.pass1" -c "SELECT 1;"
-- sleep 8s
vsql -p 5432 -d postgres -U u2 -W "u2.pass1" -c "SELECT 1;"

验证 password_reuse_time 和 password_reuse_max

CREATE PROFILE pro3 LIMIT
 password_reuse_time 0.0001 -- 不能用过去8秒使用过的密码
 password_reuse_max 100; -- 不能用过去100次使用过的

DROP USER IF EXISTS u1,u2;
CREATE USER u1 PASSWORD 'u1.pass1' PROFILE pro3;
ALTER USER u1 PASSWORD 'u1.pass2';

ALTER USER u1 PASSWORD 'u1.pass1';
SELECT pg_sleep(3);
ALTER USER u1 PASSWORD 'u1.pass1';
SELECT pg_sleep(3);
ALTER USER u1 PASSWORD 'u1.pass1';
SELECT pg_sleep(3);
ALTER USER u1 PASSWORD 'u1.pass1';

CREATE USER u2 PASSWORD 'u2.pass1';
ALTER USER u2 PASSWORD 'u2.pass2';
ALTER USER u2 PASSWORD 'u2.pass1';
ALTER USER u2 PASSWORD 'u2.pass2';
ALTER USER u2 PASSWORD 'u2.pass1';

-- -----------------------------

CREATE PROFILE pro4 LIMIT
 password_reuse_max 2 -- 不能用过去2次使用过的
 password_reuse_time 20;

DROP USER IF EXISTS u1,u2;

CREATE USER u1 PASSWORD 'u1.pass1' PROFILE pro4;
ALTER USER u1 PASSWORD 'u1.pass2';
ALTER USER u1 PASSWORD 'u1.pass3';
ALTER USER u1 PASSWORD 'u1.pass4';

ALTER USER u1 PASSWORD 'u1.pass3'; -- error
ALTER USER u1 PASSWORD 'u1.pass2'; -- ok

验证 idle_time

CREATE PROFILE pro5 LIMIT
 idle_time 0.1; -- 6s

DROP USER IF EXISTS u1,u2;

CREATE USER u1 PASSWORD 'u1.pass1' PROFILE pro5;
CREATE USER u2 PASSWORD 'u2.pass1';
\q

vsql -p 5432 -d postgres -U u1 -W "u1.pass1" -r
SELECT 1;
-- 不用pg_sleep
\! sleep 7
SELECT 1;
\q

vsql -p 5432 -d postgres -U u2 -W "u2.pass1" -r
SELECT 1;
-- 不用pg_sleep
\! sleep 7
SELECT 1;

3 view

CREATE OR REPLACE VIEW SYS.DBA_PROFILES AS
 SELECT
 profile "PROFILE",
 setname "RESOURCE_NAME",
 setkind "RESOURCE_TYPE",
 setval "LIMIT"
 FROM vb_profiles;

升级
审计
oid

knl_u_misc_init
 AuthenticatedUserId = InvalidOid
ResetStreamStatus
 AuthenticatedUserId = InvalidOid
InitializeSessionUserId
 AuthenticatedUserId = SearchSysCache(rolname / useroid)
InitializeSessionUserIdStandalone
 AuthenticatedUserId = BOOTSTRAP_SUPERUSERID

SessionUserId
CurrentUserId

create_session_context
 # get_setting_from_guc_or_profile
 enable_session_sig_alarm
 # get_setting_from_guc_or_profile
ReadCommand
 # get_setting_from_guc_or_profile
 enable_session_sig_alarm
 # get_setting_from_guc_or_profile

disable_session_sig_alarm
TpoolSchedulerMain
 CheckSessionTimeout
 # get_setting_from_guc_or_profile
handle_sig_alarm
 CheckSessionTimeout
 # get_setting_from_guc_or_profile
WaitMission
 # get_setting_from_guc_or_profile
 enable_session_sig_alarm

海量 2 设计 profile

Thu, 06 Mar 2025 11:32:00 +0800

1 Oracle兼容性-支持profile功能

1.1 功能简述

本特性实现与oracle profile相同的功能，支持为不同用户设置7个不同的配置参数：

failed_login_attempts
password_lock_time
password_life_time
password_grace_time
password_reuse_time
password_reuse_max
idle_time

简单使用示例如下：

CREATE PROFILE pro1 LIMIT failed_login_attempts 10;
CREATE USER u1 PASSWORD 'u1.pass1';
ALTER USER u1 PROFILE u1;

1.2 实现方案

一、元数据

本特性的关键实现为：对用户提供DDL接口，在内核中存储配置数据。因此，在介绍代码流程前，先介绍接口与元数据。

新增GUC参数resource_limit (与oracle参数名一致)
控制是否启用oracle profile功能。
如果该参数为on，以下5个guc参数则不再生效：[failed_login_attempts, password_lock_time, password_effect_time, password_reuse_time, password_reuse_max]。另外，对于已经过身份认证的连接，session_timeout也不再生效，相关功能均由profile中的用户级参数控制。
对于新安装的集群、旧版本升级的集群，该参数的值存在差异：
- 新安装：新安装的数据库，即3.0.8版本及之后，该guc参数值默认为on（初始值为off，由initdb自动设置为on）
- 升级：从3.0.8之前版本，升级到3.0.8版本时，在升级的过程中，该参数的值仍然是off，即升级上来默认不可用profile功能
```
SELECT * FROM pg_settings WHERE name = 'resource_limit';

 -[ RECORD 1 ]-------------------------------------------
 name | resource_limit
 setting | on -- 默认为on （由initdb设置为on，从旧版本升级到新版本时，升级脚本会将该参数设置为off）
 unit |
 category | Ungrouped
 short_desc | Used to enable profile feature
 extra_desc | default on
 context | postmaster -- 需重启生效
 vartype | bool
 source | default
 min_val |
 max_val |
 enumvals |
 boot_val | off
 reset_val | off
 sourcefile |
 sourceline |
```
修改6个GUC参数的生效条件
当GUC参数resource_limit取值为on时，以下6个GUC参数不再生效：[failed_login_attempts, password_lock_time, password_effect_time, password_reuse_time, password_reuse_max, session_timeout]

海量 2 设计 oracle profile

Thu, 20 Feb 2025 19:24:00 +0800

2

代码
新增试图

SELECT * FROM pg_user_settings;
-- 新增视图 pg_user_settings

SELECT rolname,profile FROM pg_authid WHERE rolcanlogin = true
 LEFT JOIN vb_profile ON

rolname | setname | setting | settype | settype | setsource
--------+-----------------------+----------+---------+-------------+----------------
 u1 | password_effect_time | 90 | int | profile guc | pro1
 | cluster guc | postgresql.conf

参数1: failed_login_attempts

# opegauss使用1个内存中的hash表，存储密码失败次数
ClientAuthentication
 # 进行身份认证时，如果认证失败，则更新hash表中的失败次数值
 UpdateFailCountToHashTable
 InitAccountLockHashTable
 hash_search
 # 如果失败次数超过GUC限制，则锁定账户
 if failed_login_attempts：
 lockflag = True

参数2: password_lock_time

参数3: password_effect_time

# 通过内置函数，主动查看密码剩余天数
gs_password_deadline
 GetCurrentUserId # 1 获取当前用户
 GetUserCurrentPwdtime # 2 从系统表pg_auth_history中，获取密码创建时间passwordtime
 heap_open('pg_auth_history')
 systable_beginscan
 floor(u_sess->attr.attr_security.Password_effect_time) # 3 从guc参数password_effect_time中获取密码有效天数
 # 计算步骤2和3中的时间，返回剩余过期天数

参数4: password_reuse_max

AddAuthHistory
 systable_beginscan('pg_auth_history') # 1 从系统表pg_auth_history中，获取曾用过的密码rolpassword，获取生成密码的时间passwordtime
 systable_getnext_back # 倒着从系统表扫描，即先扫描不太古老的旧密码，再扫描更古老的旧密码

 pg_sha256_encrypt # 使用旧密码的salt，加密新密码
 if strncmp : # 比较新密码是否与旧密码相等
 hasSame = True

 # 如果新旧密码相等，计算新旧密码间隔天数，与GUC参数password_reuse_time比较，判断是否满足密码重用时间限制
 if now - pg_auth_history.passwordtime > 'password_reuse_time'：
 isTimeSafe = True

 # 计算这是倒数第几个密码
 changeTimes++
 if changeTimes > 'password_reuse_max':
 isMaxSafe

 # 满足 password_reuse_time 和 password_reuse_max 中任意一个条件，都可以修改密码
 # - 要么用好几次之前的密码（满足 password_reuse_max 条件）
 # - 要么用很旧之间使用的密码（满足 password_reuse_time 条件）
 if hasSame and not isTimeSafe and not isMaxSafe:
 # 报错

参数5: password_reuse_time

海量 2 需求 profile

Wed, 19 Feb 2025 17:43:00 +0800

1 简介

1.1 目的

vastbase与oracle都支持设置运行参数：

vastbase：支持设置集群级guc参数，例如，guc参数failed_login_attempts用于设置’用户密码错误多少次后锁定账户’，该参数对集群中所有用户（非初始用户）都有效。
oracle：也支持failed_login_attempts参数，但是oracle支持为不同用户设置不同的failed_login_attempts值。我们且将此类参数称为用户级参数。

与oracle相比，vastbase的guc参数功能存在2个差异：

作用范围：oracle支持设置用户级参数，vastbase大部分参数都是集群级guc参数
参数个数：23版本的oracle支持18个用户级参数，其中6个可在vastbase找到对应的guc参数
参数取值：vastbase中，6个guc参数的取值范围与oracle profile不同

本文主要介绍以下几点：

oracle用户级参数的个数、设置方法
vastbase中对应集群级guc参数的个数、设置方法
vastbase新需求：尽量实现与oracle一致的用户级guc参数

本文档可指导开发者、测试者熟悉vastbase用户级guc配置参数特性

本文档的内容已被上传至tapd，tapd上，排版更好看，测试用例更方便复制。建议直接从tapd上查看本文档原文: https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007196

1.2 适用范围

vastbase 3.0.8及之后版本，vastbase用户级参数profile特性接口设计、使用指导等。

1.3 术语定义、首字母缩写词和缩略语

GUC：Grand Unifed Configuralion，postgresql和vastbase的配置参数

1.3 参考资料

原始需求： https://www.tapd.cn/60475194/prong/stories/view/1160475194001074627
tapd上本需求文档链接： https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007196
tapd上6个与密码相关的guc参数的使用参考： https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007200
oracle 23 profile语法以及相关参数： https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/CREATE-PROFILE.html
mysql 8.0 create user语法以及相关参数： https://mysql.net.cn/doc/refman/8.0/en/create-user.html
mysql 配置参数列表：https://mysql.net.cn/doc/refman/8.0/en/server-system-variable-reference.html
vastbase g100 create user语法以及相关参数： https://docs.vastdata.com.cn/zh_CN/VastbaseG100/V3.0.8/1/6a4766151e29496b9f88cd2d9dd3db2e

2 支持oracle用户级配置profile

2.1 功能简述

【需求来源】桂林银行

需求链接：https://www.tapd.cn/60475194/prong/stories/view/1160475194001074627
需求描述：桂林银行客户指出，目前对于数据库用户的管理方式不够便捷，无法像oracle profile方式为用户赋予一组安全策略。一些属性如密码有效期、密码过期天数、密码尝试次数等也只能全局设定，无法指定用户配置。- 需求范围：桂林银行使用的数据库兼容模式包括oracle和mysql两种兼容模式。

【需求背景】oracle 23的profile功能

通俗来讲，oracle的profle可理解为细粒度的配置参数。1个profile包含1组配置参数，不同用户可使用不同的profile。按上述例子，要单独控制某个用户的密码有效期，操作步骤如下：

创建用户

CREATE USER u1 IDENTIFIED BY "u1.1234";

创建profile，同时设置用户级参数
此处，以设置密码有效期参数为例：
```
CREATE PROFILE pro1 LIMIT FAILED_LOGIN_ATTEMPTS 10;
```
设置用户u1使用profile pro1

数据结构与算法 2 剑指offer

Tue, 21 Jan 2025 13:55:00 +0800

https://www.nowcoder.com/exam/oj/ta?page=1&tpId=13&type=13

链表

从尾到头打印链表
- 栈
- 递归
链表反转
- 栈
- 双指针
```
1 -> 2 -> 3 -> 4
1 <- 2 -> 3 -> 4
```
- 递归
合并两个有序链表
- 迭代
- 递归
两个链表的第一个公共结点
```
1 -> 2 -> 3 |
 4 -> 5 |-> 6 -> 7
```
- 栈
- 双指针：先计算长度，再找起点
- map：第一个cnt > 1的节点

链表中环的入口节点

1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8
 ^ ^
 环 相遇（相遇时，快指针多走了1个环）

快指针：1 2 3 4 5 6 7 8
 3 4 5 6 （前后长度一定相等：1 2 和 7 8）
慢指针：1 2 3 4 5 6
快指针：1 2 3 4 5
 2 3 4
满指针：1 2 3 4

map：第一个cnt > 1的节点
快慢指针：首先，找到相遇节点；然后，慢指针接着走，新指针从头走（一次一步），再次相遇。

链表倒数第K个节点
- 双指针：前指针先走K步
- 栈

复杂链表的复制

1 -> 2 -> 3 -> 4 -> 5
3 5 * 2 *
1 _1 2 _2 3 _3 4 _4 5 _5 # 1. 复制后的新节点放在旧节点之后
 3 5 * 2 * # 2. 找到旧节点的旧random节点
 _3 _5 * _2 * # 3. 旧random节点的下一个节点即为新random节点
 # 4. 拆分链表

双指针
哈希表：hash(旧节点) = 新节点

删除链表中重复节点

PostgreSQL 2-1 Parse

Tue, 21 Jan 2025 13:55:00 +0800

1 语法解析概述

1.1 语法解析的目的

语法解析的目的
用户向数据发送以下SQL语句时：
```
CREATE TABLE t1 (c1 INT, c2 TEXT);
INSERT INTO t1 VALUES (1, 'data1');
DELETE FROM t1 WHERE c1 = 1;
```
从用户的角度，掌握SQL语法后，我们很容易理解上述SQL的含义。
从PostgreSQL的角度，上述语句知识一串字符串，需要根据SQL语法的规则，从字符串中解析表名、列名、数据等关键信息。
语法解析的流程
此处将语法解析的步骤简要分为以下4个阶段：

定义语法：PostgreSQL开发人员需要根据SQL标准，制定一些类语法规则。比如：
- 当用户执行CREATE TABLE ..时，表示用户需要创建表
- 当用户执行CREATE TABLE tablename ..时，表示用户要创建的表名叫tablename
发布语法：PostgreSQL会在官网上发布其定义的各种语法
构造语句：当开发人员想让数据执行某些操作时，需根据数据库定义的语法，构造SQL语句，再让数据库执行。比如：
- 当用户想创建一个名为t1的表，需要构造SQL语句CREATE TABLE t1 ..
解析语法：PostgreSQL接收SQL语句后，根据语法规则，可解析SQL想要执行什么操作，生成1个结构体，结构中存储了SQL语句的关键信息，比如：
- 处理CREATE TABLE t1 ..，结构体中，将有1个变量表示表名，该变量的值将被复制为t1
执行语法：在解析用户操作后，生成一个结构体，即根据结构体，开始执行各种操作

1.2 语法解析的类型

PostgreSQL支持上百种语法，本文主要介绍以下4个常用的语法：

CREATE TABLE ..
SELECT .. FROM ..
INSERT INTO ..
DELETE FROM ..

2 解析语法

[ WITH [ RECURSIVE ] with_query [, ...] ]
SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
 * | expression [ [ AS ] output_name ] [, ...]
 [ FROM from_item [, ...] ]
 [ WHERE condition ]
 [ GROUP BY expression [, ...] ]
 [ HAVING condition [, ...] ]
 [ WINDOW window_name AS ( window_definition ) [, ...] ]
 [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
 [ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ]
 [ LIMIT { count | ALL } ]
 [ OFFSET start [ ROW | ROWS ] ]
 [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
 [ FOR { UPDATE | NO KEY UPDATE | SHARE | KEY SHARE } [ OF table_name [, ...] ] [ NOWAIT ] [...] ]

-- from_item
 [ ONLY ] table_name [ * ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
 [ LATERAL ] ( select ) [ AS ] alias [ ( column_alias [, ...] ) ]
 with_query_name [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
 [ LATERAL ] function_name ( [ argument [, ...] ] ) [ AS ] alias [ ( column_alias [, ...] | column_definition [, ...] ) ]
 [ LATERAL ] function_name ( [ argument [, ...] ] ) AS ( column_definition [, ...] )
 from_item [ NATURAL ] join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]

-- with_query
 with_query_name [ ( column_name [, ...] ) ] AS ( select | values | insert | update | delete )

TABLE [ ONLY ] table_name [ * ]

参考 http://www.postgres.cn/docs/9.3/sql-select.html

PostgreSQL 2-2 Analyze

Tue, 21 Jan 2025 13:55:00 +0800

1 概述

1.1 语义分析的目的

语义分析的目的
上文提到，PostgreSQL接收SQL语句时，会生成1个语法解析树，语法解析树存储了SQL语法中的关键信息。比如，在语法INSERT INTO t1 VALUES(1, 'data1')中，解析结果可说明：

这是一条用于插入数据的INSERT语法
数据将插入t1表中
要插入的数据是(1, 'data1')
…
但是，数据库执行时，还需要更多的关键信息才行，比如，在INSERT INTO t1 VALUES(1, 'data1')的语法树中，PostgreSQL需要获取一些关键信息：
数据库中是否有表叫t1
t1表有几列，每列的的数据类型是什么
语法中的值(1, 'data1')是否符合t1表的定义
…

1.2 本文的目标

本文以几个常见且简单的语法为例，介绍语义分析的详细功能

CREATE TABLE ..
SELECT .. FROM ..
INSERT INTO ..
DELETE FROM ..

1.3 语义分析的调用关系

exec_simple_query
 pg_parse_query
 pg_analyze_and_rewrite
 parse_analyze

1.1 整体流程

// 语义分析
exec_simple_query
 pg_parse_query
 pg_analyze_and_rewrite
 parse_analyze
 transformTopLevelStmt
 transformOptionalSelectInto
 transformStmt
 transformInsertStmt

exec_simple_query()
 pg_parse_query()
 for (;;):
 pg_analyze_and_rewrite()
 Query *query = parse_analyze(Node *parsetree)
 List *querytree_list = pg_rewrite_query(query)
 pg_plan_queries()
 PortalRun()

1.2 分析器

Query *parse_analyze(Node *parseTree)
 ParseState *pstate = make_parsestate()
 Query *query = query = transformTopLevelStmt(pstate, parseTree)
 query = transformStmt(pstate, parseTree) /* 对各种类型语法进行语义分析 */
 Query *result
 switch nodeTag(parseTree) {
 case T_InsertStmt:
 result = transformInsertStmt(pstate, (InsertStmt *) parseTree)
 case T_DeleteStmt:
 result = transformDeleteStmt(pstate, (DeleteStmt *) parseTree)
 case T_UpdateStmt:
 result = transformUpdateStmt(pstate, (UpdateStmt *) parseTree)
 case T_SelectStmt:
 SelectStmt *n = (SelectStmt *) parseTree;
 if n->valuesLists:
 transformValuesClause(pstate, n)
 else if n->op == SETOP_NONE:
 result = transformSelectStmt(pstate, n)
 case T_DeclareCursorStmt:
 ...
 case T_ExplainStmt:
 ...
 case T_CreateTableAsStmt:
 ...
 default:
 result = makeNode(Query)
 result->commandType = CMD_UTILITY
 result->utilityStmt = (Node *) parseTree
 }
 return result;

1.3 SELECT 分析

Query *transformSelectStmt(ParseState *pstate, SelectStmt *stmt)
 Query *qry = makeNode(Query)
 if stmt->withClause:
 qry->cteList = transformWithClause(pstate, stmt->withClause)
 transformFromClause(pstate, stmt->fromClause)
 qry->targetList = transformTargetList(pstate, stmt->targetList)
 markTargetListOrigins(pstate, qry->targetList)
 Node *qual = transformWhereClause(pstate, stmt->whereClause)
 qry->havingQual = transformWhereClause(pstate, stmt->havingClause)
 qry->sortClause = transformSortClause(pstate, stmt->sortClause, &qry->targetList)
 qry->groupClause = transformGroupClause(pstate, stmt->groupClause, &qry->groupingSets, &qry->targetList, qry->sortClause)
 qry->distinctClause = transformDistinctOnClause(pstate, stmt->distinctClause, &qry->targetList, qry->sortClause)
 qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset)
 qry->limitCount = transformLimitClause(pstate, stmt->limitCount)
 qry->windowClause = transformWindowDefinitions(pstate, pstate->p_windowdefs, &qry->targetList)
 qry->jointree = makeFromExpr(pstate->p_joinlist, qual)
 if pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual:
 parseCheckAggregates(pstate, qry)
 assign_query_collations(pstate, qry)
 return qry

PostgreSQL 2-3 Rewrite

Wed, 05 Feb 2025 18:29:00 +0800

重写功能

-- 创建2个表
CREATE TABLE t1 (c1 INT, c2 TEXT);
CREATE TABLE t2 (c1 INT, c2 TEXT);

-- 创建1条重写规则
 -- 触发条件：向t1表写入数据时
 -- 执行操作：将SQL语句重写为：同时向t2写入相同数据
CREATE OR REPLACE RULE r1 AS
 ON INSERT TO t1 DO ALSO INSERT INTO t2 VALUES (new.c1, new.c2);

-- 向t1写入一条数据
INSERT INTO t1 VALUES (1, 'abc');

-- 验证t2也写入了一条数据
SELECT * FROM t2;

DROP TABLE t1,t2;

重写规则

语法
定义重写规则的语法如下：

CREATE [ OR REPLACE ] RULE name AS
 ON { SELECT | INSERT | UPDATE | DELETE } TO table_name [ WHERE condition ]
 DO [ ALSO | INSTEAD ] { NOTHING | command | ( command ; command ... ) }

约束

PostgreSQL 2-4 Plan

Tue, 21 Jan 2025 13:55:00 +0800

SQL 引擎

1 概述

1.1 生成计划的目的

上文提到，在语法分析、语义分析之后，PostgreSQL已获取执行所需的详细信息。计划生成主要针对一些复杂的SQL语句，主要是SQL语句，计划器主要告诉PostgreSQL，如何更高效地执行复杂的SQL语句：

示例1
假设，有1个表，表上有1个索引，表中有1000万条数据
```
CREATE TABLE t1 (c1 INT, c2 TEXT);
CREATE INDEX i1 ON t1(c1);
INSERT INTO t1 .. -- 假设1000万条数据
```
当用户执行以下SQL语句时，数据库需要从t1表中，依次扫描所有的数据，此时，索引并没有什么作用：
```
SELECT * FROM t1;
```
当用户执行以下数据时，数据有2种执行方案：
语句
```
SELECT * FROM t1 WHERE c1 = 10000;
```
方案1：依次扫描t1表所有数据，然后找到c1=10000的几行
方案2：先扫描索引i1，找到c1=10000的几行数据所在的位置，再去t1表中指定位置读取数据
显然，上述示例中，方案2的执行速度更快，数据库需要根据一定的策略，选择哪种执行方案。这便是计划器的职责。

1.2 生成计划的场景

SQL语法

CREATE TABLE t1 (c1 INT, c2 TEXT);
INSERT INTO t1 VALUES (1, 'data-1'), (2, 'data-2');
ANALYZE;
SELECT * FROM pg_statistic WHERE starelid = 't1'::regclass;

1.3 计划的简单表示

1.4 算子的分类

共40个

PostgreSQL 2-5 Execute

Tue, 21 Jan 2025 13:55:00 +0800

1 概述

1.1 总接口

main
 PostmasterMain
 ServerLoop
 for (;;)
 select # 接收TCP连接
 BackendStartup
 fork_process # fork postgres进程，用于处理SQL
 # postgres子进程执行：
 BackendRun

# postgres子进程
BackendRun
 PostgresMain
 for (;;)
 ReadCommand
 exec_simple_query
 pg_parse_query # 语法解析
 pg_analyze_and_rewrite # 语义分析 查询重写
 pg_plan_queries # 计划生成
 CreatePortal
 PortalDefineQuery
 PortalStart
 PortalRun
 PortalRunSelect
 ExecutorRun # 计划执行
 standard_ExecutorRun
 ExecutePlan
 for (;;)
 ExecProcNode
 ExecSeqScan # SELECT 计划执行
 SeqNext
 heap_beginscan
 heap_getnext
 PortalRunMulti # DDL执行
 PortalRunUtility
 ProcessUtility
 standard_ProcessUtility
 ExecDropStmt # DROP TABLE
 ProcessUtilitySlow
 DefineRelation # CREATE TABLE
 ProcessQuery
 ExecutorStart
 ExecutorRun # 计划执行
 standard_ExecutorRun
 ExecutePlan
 for (;;)
 ExecProcNode
 ExecModifyTable
 ExecInsert # INSERT 计划执行
 heap_insert
 ExecUpdate # UPDATE 计划执行
 heap_update
 ExecDelete # DELETE 计划执行
 heap_delete
 ExecutorFinish
 ExecutorEnd
 PortalDrop

exec_simple_query
 pg_plan_queries
 pg_plan_query
 planner
 standard_planner
 subquery_planner
 pull_up_subqueries
 preprocess_qual_conditions
 grouping_planner
 query_planner
 make_one_rel
 set_base_rel_pathlists # 查找所有Scan类型
 set_rel_pathlist
 set_plain_rel_pathlist
 create_seqscan_path
 create_index_paths
 get_index_paths
 generate_bitmap_or_paths
 create_tidscan_paths
 get_cheapest_fractional_path
 create_plan

create_plan_recurse
 create_scan_plan

1.2 算子类型

TupleTableSlot *ExecProcNode(PlanState *node)

/* 控制算子 */
ExecResult((ResultState *) node);
ExecModifyTable((ModifyTableState *) node);
ExecAppend((AppendState *) node);
ExecMergeAppend((MergeAppendState *) node);
ExecRecursiveUnion((RecursiveUnionState *) node);

/* 扫描算子 */
ExecSeqScan((SeqScanState *) node);
ExecSampleScan((SampleScanState *) node);
ExecIndexScan((IndexScanState *) node);
ExecIndexOnlyScan((IndexOnlyScanState *) node);
ExecBitmapHeapScan((BitmapHeapScanState *) node);
ExecTidScan((TidScanState *) node);
ExecSubqueryScan((SubqueryScanState *) node);
ExecFunctionScan((FunctionScanState *) node);
ExecValuesScan((ValuesScanState *) node);
ExecCteScan((CteScanState *) node);
ExecWorkTableScan((WorkTableScanState *) node);
ExecForeignScan((ForeignScanState *) node);
ExecCustomScan((CustomScanState *) node);

/* 连接算子 */
ExecNestLoop((NestLoopState *) node);
ExecMergeJoin((MergeJoinState *) node);
ExecHashJoin((HashJoinState *) node);

/* 物化算子 */
ExecMaterial((MaterialState *) node);
ExecSort((SortState *) node);
ExecGroup((GroupState *) node)
ExecAgg((AggState *) node);
ExecWindowAgg((WindowAggState *) node)
ExecUnique((UniqueState *) node);
ExecHash((HashState *) node);
ExecSetOp((SetOpState *) node)
ExecLockRows((LockRowsState *) node);
ExecLimit((LimitState *) node);

2 算子

2.1 ExecSort

/* 主要流程 */
TupleTableSlot *ExecSort(SortState *node)
 Tuplesortstate *tuplesortstate = node->tuplesortstate

 if !node->sort_Done:
 PlanState *outerNode = outerPlanState(node)
 tuplesortstate = tuplesort_begin_heap(ExecGetResultType(outerNode), numCols, sortColIdx, sortOperators)
 for (;;) /* 子节点扫描tup */
 slot = ExecProcNode(outerNode)
 tuplesort_puttupleslot(tuplesortstate, slot)
 tuplesort_performsort(tuplesortstate)

 slot = node->ss.ps.ps_ResultTupleSlot
 tuplesort_gettupleslot(tuplesortstate, ScanDirectionIsForward(dir), slot)
 return slot

/* 1 准备 */
Tuplesortstate *tuplesort_begin_heap(TupleDesc tupDesc, int nkeys, AttrNumber *attNums, Oid *sortOperators, Oid *sortCollations, bool *nullsFirstFlags)
 Tuplesortstate *state;
 state->comparetup = comparetup_heap
 state->copytup = copytup_heap;
 state->writetup = writetup_heap
 state->readtup = readtup_heap

 state->sortKeys = palloc0(nkeys * sizeof(SortSupportData))
 for i in range(nkeys):
 SortSupport sortKey = state->sortKeys + i
 sortKey->ssup_attno = attNums[i]

/* 2 扫描存储 */
void tuplesort_puttupleslot(Tuplesortstate *state, TupleTableSlot *slot)
 SortTuple stup
 COPYTUP(state, &stup, (void *) slot)
 puttuple_common(state, &stup) {
 switch state->status:
 case TSS_INITIAL:
 if state->memtupcount >= state->memtupsize:
 grow_memtuples(state)
 state->memtuples[state->memtupcount++] = *tuple
 if state->bounded:
 make_bounded_heap(state)
 inittapes(state) {
 int maxTapes = tuplesort_merge_order(state->allowedMem) + 1
 tapeSpace = (int64) maxTapes *TAPE_BUFFER_OVERHEAD
 /* 创建临时文件 */
 PrepareTempTablespaces()
 state->tapeset = LogicalTapeSetCreate(maxTapes)
 state->mergenext = palloc0(maxTapes * sizeof(int))
 state->mergeavailslots = palloc0(maxTapes * sizeof(int))
 ...
 ntuples = state->memtupcount
 state->memtupcount = 0
 for j = 0; j < ntuples; j++
 SortTuple stup = state->memtuples[j]
 tuplesort_heap_insert(state, &stup, 0, false)
 ...
 state->status = TSS_BUILDRUNS
 }
 dumptuples(state, false) {
 while state->memtupcount >= state->memtupsize:
 /* = writetup_heap */
 WRITETUP(state, state->tp_tapenum[state->destTape], &state->memtuples[0])
 tuplesort_heap_siftup(state, true)
 if state->memtupcount == 0 || state->currentRun != state->memtuples[0].tupindex:
 markrunend(state, state->tp_tapenum[state->destTape])
 state->currentRun++
 if state->memtupcount == 0:
 break
 selectnewtape(state)
 }
 case TSS_BOUNDED:
 if COMPARETUP(state, tuple, &state->memtuples[0]) <= 0:
 free_sort_tuple(state, tuple)
 else:
 free_sort_tuple(state, &state->memtuples[0])
 tuplesort_heap_siftup(state, false)
 tuplesort_heap_insert(state, tuple, 0, false)
 case TSS_BUILDRUNS:
 if COMPARETUP(state, tuple, &state->memtuples[0]) >= 0:
 tuplesort_heap_insert(state, tuple, state->currentRun, true)
 else:
 tuplesort_heap_insert(state, tuple, state->currentRun + 1, true)
 dumptuples(state, false)
 }

/* 3 排序 */
void tuplesort_performsort(Tuplesortstate *state)
 switch state->status:
 case TSS_INITIAL: /* 可在内存存放所有tup */
 if state->memtupcount > 1:
 if state->onlyKey != NULL:
 qsort_ssup(state->memtuples, state->memtupcount, state->onlyKey)
 else:
 qsort_tuple(state->memtuples, state->memtupcount, state->comparetup, state)
 state->current = 0;
 state->status = TSS_SORTEDINMEM
 case TSS_BOUNDED: /* 使用堆排消除多余tup*/
 sort_bounded_heap(state)
 state->status = TSS_SORTEDINMEM
 case TSS_BUILDRUNS:
 dumptuples(state, true) /* 将内存中所有元组写到持久化存储tape */
 mergeruns(state) /* 合并执行 */

2.2 tup读写

writetup_heap(Tuplestorestate *state, void *tup)
 MinimalTuple tuple = (MinimalTuple) tup

PostgreSQL 2-6 Catalog

Tue, 21 Jan 2025 13:55:00 +0800

1 常用系统表与视图

1.1 系统表

1.2 视图

堆内存（区分线程）

SELECT * FROM gs_thread_memory_context ORDER BY totalsize DESC;

堆内存（不区分线程）

SELECT * FROM gs_shared_memory_detail ORDER BY totalsize DESC;

会话
```
SELECT * FROM pg_stat_activity;
```

1 新增系统表

获取空闲的oid

cd src/include/catalog/
chmod +x unused_oids
./unused_oids

2 读取系统表

创建表时涉及的系统表操作：

heap_create_with_catalog()
 Relation pg_class_desc = heap_open(RelationRelationId)
 Oid old_type_oid = GetSysCacheOid2(TYPENAMENSP)
 Oid relid = GetNewRelFileNode(pg_class_desc)
 Relation new_rel_desc = heap_create(relname)
 ObjectAddress new_type_addr = AddNewRelationType(relname)
 AddNewRelationTuple(pg_class_desc, new_rel_desc)
 AddNewAttributeTuples(relid, new_rel_desc->rd_att)

 ObjectAddress myself, referenced;
 myself.objectId = relid
 referenced.objectId = relnamespace

 recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL)
 recordDependencyOnOwner(RelationRelationId, relid)
 recordDependencyOnNewAcl(RelationRelationId, relid)
 recordDependencyOnCurrentExtension(&myself)
 StoreConstraints(new_rel_desc, cooked_constraints)

打开系统表

Relation heap_open(Oid relationId, LOCKMODE lockmode)
 Relation r = relation_open(relationId, lockmode)
 LockRelationOid(relationId, lockmode)
 Relation r = RelationIdGetRelation(relationId)
 Relation rd
 RelationIdCacheLookup(relationId, rd)
 RelIdCacheEnt hentry = hash_search(RelationIdCache, relationId)
 rd = hentry->reldesc
 RelationIncrementReferenceCount(rd)
 /* find cache, return */
 if !rd->rd_isvalid:
 if (rd->rd_rel->relkind == RELKIND_INDEX)
 RelationReloadIndexInfo(rd);
 else:
 RelationClearRelation(rd)
 return rd;
 /* no cache, so build */
 rd = RelationBuildDesc(relationId)
 HeapTuple pg_class_tuple = ScanPgRelation(targetRelId)
 relid = HeapTupleGetOid(pg_class_tuple)
 Form_pg_class relp = (Form_pg_class) GETSTRUCT(pg_class_tuple)
 relation = AllocateRelationDesc(relp)
 RelationGetRelid(relation) = relid
 RelationBuildTupleDesc(relation)
 if ..:
 RelationBuildRuleLock(relation)
 if ..:
 RelationBuildTriggers(relation)
 if ..:
 RelationBuildRowSecurity(relation)
 RelationParseRelOptions(relation, pg_class_tuple)
 RelationInitLockInfo(relation)
 RelationInitPhysicalAddr(relation)
 heap_freetuple(pg_class_tuple)
 RelationIncrementReferenceCount(rd)
 pgstat_initstats(r)

typedef struct {
 Oid reloid;
 Relation reldesc;
} RelIdCacheEnt;

扫描系统表

PostgreSQL 2-6 Alias

Tue, 21 Jan 2025 13:55:00 +0800

SQL.别名

摘要

本文以实际使用为例，介绍SQL语法中别名的使用约束

SQL.别名

1 介绍

什么是别名：

别名语法:

表名 | 列名 | 表名.列名 [AS] 别名

2 示例

0 建表

CREATE TABLE t1 (
 c1 INT,
 c2 INT,
 c3 INT
);

INSERT INTO t1 VALUES (1, 1, 1), (2, 2, 2);

1 [列] 别名：

SELECT
 c1 AS col1
FROM
 t1;

2 [表] 别名：

SELECT
 c1
FROM
 t1 AS tbl1;

3 [表.列] 别名：

PostgreSQL 2-8 join

Thu, 20 Feb 2025 19:26:00 +0800

1 介绍JOIN

2 使用JOIN

CREATE TABLE t1 (a1 INT, b1 TEXT);
INSERT INTO t1 VALUES
 (1, 'u1'),

 (2, 'u2'),

 (3, 'u3');

CREATE TABLE t2 (b2 TEXT, c2 TEXT);
INSERT INTO t2 VALUES
 ('u1', 'u1-1'),
 ('u1', 'u1-2'),

 ('u2', 'u2-1'),

 ('u4', 'u4-1');

-- INNER JOIN
SELECT a1, b1, b2, c2
FROM t1 INNER JOIN t2
ON b1 = b2
ORDER BY a1, b1, c2;

 a1 | b1 | b2 | c2
----+----+----+------
 1 | u1 | u1 | u1-1
 1 | u1 | u1 | u1-2
 2 | u2 | u2 | u2-1

-- LEFT JOIN
SELECT a1, b1, b2, c2
FROM t1 LEFT JOIN t2
ON b1 = b2
ORDER BY a1, b1, c2;

 a1 | b1 | b2 | c2
----+----+----+------
 1 | u1 | u1 | u1-1
 1 | u1 | u1 | u1-2
 2 | u2 | u2 | u2-1
 3 | u3 | |

-- RIGHT JOIN
SELECT a1, b1, b2, c2
FROM t1 RIGHT JOIN t2
ON b1 = b2
ORDER BY a1, b1, c2;

 a1 | b1 | b2 | c2
----+----+----+------
 1 | u1 | u1 | u1-1
 1 | u1 | u1 | u1-2
 2 | u2 | u2 | u2-1
 | | u4 | u4-1

-- FULL JOIN
SELECT a1, b1, b2, c2
FROM t1 FULL JOIN t2
ON b1 = b2
ORDER BY a1, b1, c2;

 a1 | b1 | b2 | c2
----+----+----+------
 1 | u1 | u1 | u1-1
 1 | u1 | u1 | u1-2
 2 | u2 | u2 | u2-1
 3 | u3 | |
 | | u4 | u4-1

-- SELF JOIN
SELECT a1, b1, b2, c2
FROM t1 SELF JOIN t2
ON b1 = b2
ORDER BY a1, b1, c2;

-- CROSS JOIN
SELECT a1, b1, b2, c2
FROM t1 CROSS JOIN t2 -- can't use 'ON'
ORDER BY a1, b1, c2;

 a1 | b1 | b2 | c2
----+----+----+------
 1 | u1 | u1 | u1-1
 1 | u1 | u1 | u1-2
 1 | u1 | u2 | u2-1
 1 | u1 | u4 | u4-1
 2 | u2 | u1 | u1-1
 2 | u2 | u1 | u1-2
 2 | u2 | u2 | u2-1
 2 | u2 | u4 | u4-1
 3 | u3 | u1 | u1-1
 3 | u3 | u1 | u1-2
 3 | u3 | u2 | u2-1
 3 | u3 | u4 | u4-1

PostgreSQL 2-9 cache

Wed, 26 Feb 2025 18:10:00 +0800

@vb
GaussDBThteadMain
 BackendRun
 PostgresMain
 PostgresInitializer::InitBackendWorker
 ::InitSession
 ::InitSysCache # 1 初始化缓存
 RelationCacheInitializePhase2
 if lsc:
 LocalTabDefCache::InitPhase2
 Formrdesc("vb_profiles“")
 else:
 formrdesc("vb_profiles“)
 InitCatalogCache
 ::CheckAuthentication
 PerformAuthentication
 ClientAuthentication
 ::InitUser
 InitializeSessionUserId
 ::SetDatabase
 ::SetDatabaseByName
 ::InitSessionDatabase
 ::LockDataBase
 ::LoadSysCache # 2 初始化缓存
 RelationCacheInitializePhase3
 if lsc:
 LocalTabDefCache::InitPhase3
 LoadCriticalIndex
 else:
 load_critical_index(ProfileRelationId)
 InitDatabase
 FinishInit

InitCatalogCache

RelationCacheInitialize

PostgreSQL 2-10 function

Wed, 01 Jul 2026 15:19:00 +0800

exec_simple_query('SELECT * FROM t1 WHERE c1 > 10')
 pg_parse_query
 pg_analyze_and_rewrite
 parse_analyze
 transformStmt
 transformSelectStmt
 transformWhereClause
 transformExpr
 transformAExprOp
 oper
 oper_search # 查找操作符所有相关函数
 enforce_generic_type_consistency # 根据已知数据类型，找到最符合的函数，自动调用隐式转换
 make_op
 pg_plan_queries
 PortalRun
 ExecInterpExpr
 ExecEvalExprSwitchContext
 -- ciphera_gt / int4gt

海量 3 需求 pg_hba.conf加密

Tue, 01 Apr 2025 15:42:00 +0800

1 需求背景

客户使用vb什么版本？ 2215
客户的要求：

2 需求分析

2.1 适配点

在使用vastbase的多个阶段，都可能涉及pg_hba.conf

编译安装
初始化
升级
配置
- gs_guc修改pg_hba
- 手动编辑pg_hba
启动
运维
- pg_backup
- pg_rewind
- vb_ctl restart

2.2 代码流程

编译

初始化

main # initdb.cpp
 canonicalize_path # PGDATA
 find_other_exec # 在gs_initdb bin目录下，查找gaussdb bin
 # 在$GAUSSHOME/share/postgrsql目录下，检查以下文件是否存在
 check_input('postgres.bki, postgres.description, pg_hba.conf.sample, postgresql.conf.sample, ..., system_views.sql, ...')
 check_locale_encoding
 init_log
 gs_getenv_r('GAUSSLOG')
 canonicalize_path('$PGDATA/PG_VERSION')
 fprintf(PG_MAJORVERSION = '9.2')
 setup_config
 readfile("postgresql.conf.sample")
 readfile("pg_hba.sample")
 writefile("pg_hba.conf")
 bootstrap_template1
 write_version_file
 setup_auth
 get_set_pwd
 setup_depend
 load_plpgsql
 setup_sysviews

升级
配置
启动
```
pg_ctl
```

运行

PostmasterMain # postmaster 线程
 InitializeGUCOptions
 getopt_r
 load_hba # 加载hba
 ServerLoop
 ConnCreate
 StreamConnection
 BackendStartup
 PostgresMain # postgres 线程
 InitBackendWorker
 InitSession
 CheckAuthentication
 PerformAuthentication
 port->protocol_config->fn_authenticate
 ClientAuthentication
 hba_getauthmethod
 check_hba
 g_instance.libpq_cxt_comm_parsed_hba_lines # 读取缓存的hba
 if init_user:
 get_default_auth_method
 else:
 check_hostname
 sendAuthRequest
 recv_and_check_password_packet # 接收客户端的password
 crypt_verify
 for (;;)
 ReadCommand
 exec_simple_query('SQL')

SIGHUB_handler
 load_hba

运维

海量 3 需求 oracle resource

Mon, 24 Mar 2025 10:42:00 +0800

| -| -| -| -| -| -| -|
| 1 | FAILED_LOGIN_ATTEMPTS | [1, max] unlimited | failed_login_attempts | [1,1000] | 认证类 | 登录数据库时，如果密码错误次数超过<本参数>，则账号会被锁定，短期内无法再登录 |
| 2 | PASSWORD_LOCK_TIME | [1, max] unlimited | password_lock_time | [1,525600]min | 认证类 | 如果因密码错误次数过多，导致账号被锁，将锁定<本参数>的时间 |
| 3 | PASSWORD_LIFE_TIME | [1, max] unlimited | password_effect_time | [30,36500]day | 认证类 | 设置或更新用户密码时，超过<本参数>的时间，密码会过期（oracle与vastase表现不同） |
| 4 | PASSWORD_GRACE_TIME | - | - | - | 认证类 | 如果密码过期，在<本参数>的时间内，密码仍可使用 |
| 5 | PASSWORD_REUSE_TIME | [1, max] unlimited | password_reuse_time | [30, 90]day | 认证类 | 用户设置密码时，如果密码在过去的<本参数>的时间内别用过，则密码不能复用，opengauss [0,3650] |
| 6 | PASSWORD_REUSE_MAX | - | password_reuse_max | [1,100] | 认证类 | 用户设置密码时，如果密码已被重复使用过<本参数>的次数，则密码不能复用 |
| 7 | INACTIVE_ACCONT_TIME | - | - | - | 认证类 | 如果一个账号在<本参数>的时间内，未登录过，则锁定账号 |
| 8 | PASSWORD_VERIFY_FUNCTION | - | - | - | 认证类 | 用户设置密码时，调用<本参数>指定的函数，检查密码是否符合要求 |
| 9 | PASSWORD_ROLLOVER_TIME | - | - | - | 认证类 | 新旧密码滚动更新天数 |
| 10 | SESSIONS_PER_USER | - | - | - | 资源类 | 1个用户可建立的最大连接数 |
| 11 | CPU_PER_SESSION | - | - | - | 资源类 | 1个连接可使用CPU时间数 |
| 12 | CPU_PER_CALL | - | - | - | 资源类 | 1个调用（比如1个SQL）可使用CPU时间数 |
| 13 | CONNECT_TIME | - | - | - | 资源类 | 1个连接可持续的时间 |
| 14 | IDLE_TIME | [1, max] unlimited | session_timeout | [0,86400] | 资源类 | 1个连接空闲时间限制 |
| 15 | LOGICAL_READS_PER_CALL | - | - | - | 资源类 | 1次调用（比如1个SQL）允许读写的page数量 |
| 16 | LOGICAL_READS_PER_SESSION | - | - | - | 资源类 | 1个连接允许读取的page数量 |
| 17 | PRIVATE_SGA | - | - | - | 资源类 | 1个连接可使用的共享内存空间大小 |
| 18 | CONPOSITE_LIMIT | - | - | - | 资源类 | 1个连接可可使用的总资源：按cpu时间、连接时间、page读写数等加权求和 |

数据结构与算法 3 排序

Tue, 21 Jan 2025 13:55:00 +0800

1 概述

1.1 衡量标准

1.2 分类

算法	思想	最好时间复杂度	最坏时间复杂度	时间复杂度	空间复杂度	稳定性
冒泡排序	比较、交换	O(n)	O(n^2)	O(n^2)	O(1)	稳定，值相等不交换
插入排序	比较、移动	O(n)	O(n^2)	O(n^2)
选择排序	比较、交换
归并排序
快速排序
堆排序
桶排序
计数排序
基数排序

/* 冒泡排序 */
void sort_bubble(int *arr, int arrlen)
{
 int end;
 int tmp;
 int i;

 end = arrlen - 1;
 for (end = arrlen - 1; end > 1; end--) {
 for (i = 0; i < end - 1; i++) {
 if (arr[i] < arr[i + 1]) {
 tmp = arr[i];
 arr[i] = arr[i + 1];
 arr[i + 1] = tmp;
 }
 }
 }
}

PostgreSQL 3-2 Page

Tue, 21 Jan 2025 13:55:00 +0800

1 Page的概念

1.1 前置概念

首先，简单介绍一些基本概念：

关系 Relation：PostgreSQL是一款关系型数据库，在数据库中，1个表对应关系代数中的1个关系，即1个Relation。本博客中，将1个Relation指1个表
数据文件 RelFile：通过CREATE TABLE t1 (c1 INT, c2 TEXT)等语法创建1个表时，PostgreSQL会生成1个与表对应的数据文件，表中数据都将被存储至数据文件中
数据库页 Page：1个数据文件，由1个或多个大小为8192字节（即8k）的数据页组成
行 Row：在SQL语法INSERT INTO t1 VALUES (1, 'data1')中，(1, 'data1')是表中的1行数据
元组 Tuple：在PostgreSQL中，1个Tuple存储1行数据，数据越长，Tuple越长。1个Page可以存储多个Tuple

1.2 Page

Page的格式如下：

数据库安全 0 postgresql表级透明加密

Tue, 21 Jan 2025 13:55:00 +0800

1 特性背景
2 实现方案
3 关键设计
4 特性源码
参考

1 特性背景

2 实现方案

2.1 系统表

1. pg_key_info 密钥信息

keyoid	keyname	type	alrotithm	storage	access	protect	create_time	round
1	mk_1	master_key	any	localkms	path=./keyfile	$pass1	2024/02/01 13:01:01	-
2	dk_1	date_key	aes_256_cbc	database	m100.d100.b1.i2	mk1	2024/02/01 13:01:01	0

2. pg_key_data 密钥数据

oid	keydata	algorithm
3	abcd1234	aes_256

3. pg_encryption 加密对象

type	name	oid	special	protect	oldest_round
table	t1	100	-	dk_1	1

2.2 定义表

定义表
定义表的语法与非加密表一致，我们通过单独的语法定义ENCRYPTION。

PostgreSQL 3-6 Smgr

Tue, 21 Jan 2025 13:55:00 +0800

接口

void smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo); // 创建文件
void smgrdounlink(SMgrRelation reln, bool isRedo);

SMgrRelation smgropen(RelFileNode rnode, BackendId backend);
void smgrclose(SMgrRelation reln);

void smgrwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync);
void smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer);
void smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, char *buffer, bool skipFsync);

调用关系

// 索引模块
btbuildempty()
 smgrwrite(metapage)
_bt_blwritepage()
 smgrwrite()
spgbuildempty()
 smgrwrite()

|- FlushBuffer() ...
|- FlushRelationBuffers()
|- LocalBufferAlloc()
 smgrwrite()

// FlushBuffer
|- BufferAlloc() // readBuffer时，申请一个buffer，可能调用页面淘汰算法
|- FlushDatabaseBuffers()
|- FlushRelationBuffers()
|- FlushOneBuffer()
 FlushBuffer()

// FlushOneBuffer
XLogReadBufferForRedoExtended()
 FlushOneBuffer()

// FlushRelationBuffers
|- heap_sync()
|- ATExecSetTableSpace() // ALTER TABLE SET TABLESPACE
 FlushRelationBuffers()
// heap_sync when HEAP_INSERT_SKIP_WAL
|- intorel_shutdown()
|- CopyFrom()
|- transientrel_shutdown()
|- ATRewriteTable()
 heap_sync()

// FlushDatabaseBuffers
dbase_redo()
 FlushDatabaseBuffers()

write时机：

readBuffer时，如果buffer不在内存，且共享缓冲池已满，调用页面置换算法进行刷盘
alter table set table space
copy

PostgreSQL 3-3 Buffer

Tue, 21 Jan 2025 13:55:00 +0800

1 Buffer基本介绍

1.1 Buffer解决的问题

实际应用场景中，PostgreSQL可能需要1分钟处理数十万次事务，频繁读写Page。Buffer提供以下2个基本功能：

加载Page至内存：PostgreSQL需要读写数时，都需先从磁盘中，将指定的Page加载至内存中，再在内存中操作Page
缓存常用Page：Page被加载至内存后，还会在内存停留一段时间，降低PostgreSQL直接从磁盘读写Page的频率

1.2 Buffer的基本功能

Buffer缓存Page时，需考虑以下几个场景：

插入Page：大部分事务操作表的Page时，先从Buffer中查找Page，如果Page不在Buffer中，再从磁盘读取Page，将其放入Buffer中，再操作Buffer中的Page
查找Page：访问Page时，通过文件名和Page编号等信息可确定唯一Page
访问Page：所有事务均可访问Buffer，需考虑多事务并发读写同一Pape的场景
淘汰Page：Buffer能缓存的Page数量有限，在Page数量过多时，需淘汰一些Page
落盘Page：Buffer中通常缓存表数据文件的Page，前文提到，事务持久化的标志是WAL日志落盘，因此，Buffer中的Page无需实时落盘，仅需异步落盘即可

2 Buffer的基本原理

2.1 插入Page

插入Page主要由读Page操作触发，上层函数读取Page的主要流程如下：

上层模块统一调用ReadBuffer()接口，读取指定表的指定Page
ReadBuffer()中，先从Buffer查找Page，如果找到Page，则直接返回Buffer中的Page
如果未从Buffer找到Page，现在Buffer中预留存储Page的空间
之后，调用Smgr模块，从磁盘读取指定Page，并将其放入预留的空间内，再返回Buffer中的Page

函数调用关系大概如下图所示：

ReadBuffer(Relation, BlockNumber) # 1
 ReadBufferExtended()
 ReadBuffer_common()
 BufferAlloc() # 2,3 查找Page，如找到，返回；如未找到，预留存储Page的空间
 smgrread(.., BlockNumber) # 4 如果未找到Page，从磁盘将Page读入预留的Page空间内，返回

2.2 查找Page

上层函数读Page时，首先进入查找Page阶段。

1.1 buffer池模型

模型：

1.2 buffer池接口

缓冲区接口：

/* bufmgr.h */

/* 1 buffer池管理 */
void InitBufferPool(void);
void InitBufferPoolAccess(void);
void InitBufferPoolBackend(void);

/* 2 buffer管理 */
/* 2.1 读buffer */
Buffer ReadBuffer(Relation reln, BlockNumber blockNum);
Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy);
Buffer ReadBufferWithoutRelcache(RelFileNode rnode, ForkNumber forkNum, BlockNumber blockNum,ReadBufferMode mode, BufferAccessStrategy strategy);
/* 2.2 清理buffer */
oid ReleaseBuffer(Buffer buffer);
void UnlockReleaseBuffer(Buffer buffer);
void MarkBufferDirty(Buffer buffer);
void IncrBufferRefCount(Buffer buffer);
Buffer ReleaseAndReadBuffer(Buffer buffer, Relation relation, BlockNumber blockNum);
/* 2.3 刷盘buffer */
void CheckPointBuffers(int flags);
void FlushOneBuffer(Buffer buffer);
void FlushRelationBuffers(Relation rel);
void FlushDatabaseBuffers(Oid dbid);
void BufmgrCommit(void);
bool BgBufferSync(void);
/* 2.4 删除关联buffer */
void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber forkNum, BlockNumber firstDelBlock);
void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
void DropDatabaseBuffers(Oid dbid);
/* 2.5 锁buffer */
void UnlockBuffers(void);
void LockBuffer(Buffer buffer, int mode);
bool ConditionalLockBuffer(Buffer buffer);
void LockBufferForCleanup(Buffer buffer);
bool ConditionalLockBufferForCleanup(Buffer buffer);
bool HoldingBufferPinThatDelaysRecovery(void);

1.3 buffer调用

插入数据

PostgreSQL 3-7 Xlog

Tue, 21 Jan 2025 13:55:00 +0800

5 wal落盘

WalWriterMain
 for ::
 XLogBackgroundFlush
 LWLockAcquire(LW_EXCLUSIVE)
 XLogWrite
 LWLockRelease()

CommitTransaction
 RecordTransactionCommit
 BufmgrCommit
 XactLogCommitRecord # xlog记录commit
 TransactionTreeSetCommitTsData
 XLogFlush(XactLastRecEnd)
 for ::
 WaitXLogInsertionsToFinish
 XLogWrite
 write
 ResourceOwnerRelease
 AtEOXact_Buffers
 AtEOXact_RelationCache
 ...

1 概述

1.1 背景

https://zhmin.github.io/posts/postgresql-wal-format/
wal机制解决的问题：持久性、原子性、性能、数据同步、恢复

持久性需求：

执行一次事务/事务块，例如INSERT语句，除了要写数据文件，还需要更新系统表、索引文件、fsm文件、vm文件、事务提交文件等

为避免故障导致数据丢失，产生的数据写入磁盘才算事务成功

应用 数据库 磁盘
| 1. INSERT (5) --> |
 | 2. 读取数据页 <-- |
 | 3. 将数据写入数据页
 | 4. 存储数据页 --> |
 | 5. 读取索引文件 --> |
 | 6...
 | 7. 读取fsm文件 --> |
 | 8...
 | 9. 读取vm文件 --> |
 | 10...
| 11. INSERT 成功 <-- |

原子性需求：

PostgreSQL 3-2 Transation (v2)

Fri, 03 Jul 2026 16:51:00 +0800

概述

假如，2个会话，并发写入数据：

BEGIN;
INSERT INTO t1 VALUES(1, 'data1');
COMMIT;

BEGIN;
INSERT INTO t1 VALUES(1, 'data2');
COMMIT;

加锁逻辑：

exec_simple_query
 pg_parse_query
 pg_analyze_and_rewrite
 pg_plan_queries
 PortalStart
 PortalRun
 PortalRunMulti
 ProcessQuery
 ExecutorStart
 standard_ExecutorStart
 InitPlan
 ExecInitNode
 ExecInitModifyTable
 ExecInitResultRelation
 ExecGetRangeTableRelation
 table_open(relation, 'RowExclusiveLock') # 8级锁，行级排他锁
 relation_open
 LockRelationOid
 LockAcquire
 ExecutorRun
 standard_ExecutorRun
 ExecutePlan
 ...
 ExecInsert
 table_tuple_insert
 heapam_tuple_insert
 heap_insert
 RelationGetBufferForTuple
 LockBuffer
 LWLockAcquire(buffer, 'LW_EXCLUSIVE') # 读写锁
 RelationPutHeapTuple
 log_heap_insert

锁
HWLock
- 8级
- relation, index, buffer
- 死锁检测
LWLocks
- buffer
SpinLock
PresicateLock

HWLock

锁	取值	操作
AccessShareLock	1	SELECT
RowShareLock	2	SELECT FOR UPDATE/SHARE
RowExclusiveLock	3	INSERT/UPDATE/DELETE
ShareUpdateExclusiveLock	4	VACUUM/ANALYZE/CRATE INDEX CONCURRENTLY
ShareLock	5	CREATE INDEX
ShareRowExclusiveLock	6	row share
ExclusiveLock	7	block ROW SHARE/SELECT FOR UPDATE
AccessExclusiveLock	8	ALTER TABLE/DROP TABLE/VACUUM FULL

LockRelationOid
 LockAcquireExtended
 hash_search

所有进程共享

PostgreSQL 3-2 Transation

Tue, 21 Jan 2025 13:55:00 +0800

1 事务的概念

1.1 事务的基本特性

事务的4个特性：

原子性 Automicity
一致性 Consistency
隔离性 Isolation
持久性 Durability

1.2 事务的隔离性

不同隔离级别下，可能出现的异常如下：（T 表示可能）

异常	读未提交	读已提交	可重复读	可串行化	解释
脏读	T	.	.	.	读其他事务未提交数据
不可重复读	T	T	.	.	2次读取数据不一致
幻读	T	T	T	.	2次读取数据条数不一致

postgresql默认的隔离级别是读已提交

-- 查看默认事务隔离级别
show default_transaction_isolation;
 default_transaction_isolation
-------------------------------
 read committed

-- 查询当前的事务快照 pg 10
SELECT txid_current_snapshot();
 txid_current_snapshot
-----------------------
 1081:1081:

-- 查询所有正在活跃的进程
SELECT * FROM pg_stat_activity;

--

1.3 事务的实现

为实现事务，有3种并发控制机制：

PostgreSQL 3-5 FSM

Tue, 21 Jan 2025 13:55:00 +0800

1 概述

1.1 思想

fsm结构

用数组表示完全二叉树
```
 | 8 |
 | 4 | 8 |
| 4 | 2 | 1 | 8 |
```

1.2 FSM涉及

物理页号

 +-------+-------+-------+-------+-------+
FSMFile | 8k | 8k | 8k | 8k | ... |
 +-------+-------+-------+-------+-------+
FSMBlock | 0 | 1 | 2 | 3 | ... |
 +-------+-------+-------+-------+-------+

逻辑页号
第2层：1个FSMBlock
第1层：4069个FSMBlock
第0层：4069 * 4069个FSMBlock，每个FSM可映射4069个DataBlock
FSMAddress: [层次，页号]，页号即FSMBlock号
每个表最大容量是32T，只需3层也页面即可管理整个表的空闲空间

# [FSMAddress.level, FSMAddress.logpageno, FSMBlockNum（1个page即1个FSMBlock）]
 [2,0,0]
 |
 +---------------------------+---------------------------+
 | | |
 [1,0,1] [1,1,1*4070+1] ... [1,4069,4069*4070+1] 本层共4069个FSMBlock
 |
 +----------+------------+
 | | |
 [2,0,1+1] [2,1,1+2] ... [2,2,1+4069] ...... 本层共4069*4069个FSMBlock
 |
（映射DataBlock 0 ~ 4065）

整体架构
3层FSMBlock

 [8]
 [8 0]
 [8 0 0 0]
 [...]
 [8 0 0 0 0 ...]

 [8]
 [8 0]
 [8 0 0 0]
 [...]
 [8 0 0 0 0 ...]

[8]
[8 0]
[8 0 0 0]
[...]
[8 0 0 0 0 ...]

测试

PostgreSQL 3-10 VM

Tue, 21 Jan 2025 13:55:00 +0800

1 概述

1.1 vm接口调用点

heap_insert()
 buffer = RelationGetBufferForTuple()
 RelationPutHeapTuple(buffer, heaptup)
 if PageIsAllVisible(buffer):
 PageClearAllVisible(buffer)
 visibilitymap_clear(ItemPointerGetBlockNumber(heaptup), vmbuffer)
 MarkBufferDirty(buffer)

#define PageIsAllVisible(page) ((page)->pd_flags & PD_ALL_VISIBLE)

1.2 vm模块对外接口

visibilitymap_clear(Relation rel, BlockNumber heapBlk, Buffer buf, uint8 flags)
 int mapByte = HEAPBLK_TO_MAPBYTE(heapBlk)
 LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE)
 char *map = PageGetContents(buf)
 if map[mapByte]

1.3 vmmap结构与定位

/* 8192 - 24 = 8168 */
#define MAPSIZE (BLCKSZ - MAXALIGN(SizeOfPageHeaderData))

/* 1字节 2bit表示1页 : | 00 00 00 00 | */
#define BITS_PER_BYTE 8
#define BITS_PER_HEAPBLOCK 2
/* 1字节 可映射4个heapblock */
#define HEAPBLOCKS_PER_BYTE (BITS_PER_BYTE / BITS_PER_HEAPBLOCK)

/* 计算heapblock对应的vmblock, vmbyte, vmoffset的位置 */
/* 1vmblock可映射4 * 8168个datablock */
#define HEAPBLOCKS_PER_PAGE (MAPSIZE * HEAPBLOCKS_PER_BYTE)
#define HEAPBLK_TO_MAPBLOCK(x) ((x) / HEAPBLOCKS_PER_PAGE)
#define HEAPBLK_TO_MAPBYTE(x) (((x) % HEAPBLOCKS_PER_PAGE) / HEAPBLOCKS_PER_BYTE)
#define HEAPBLK_TO_OFFSET(x) (((x) % HEAPBLOCKS_PER_BYTE) * BITS_PER_HEAPBLOCK)

#define VISIBILITYMAP_ALL_VISIBLE 0x01
#define VISIBILITYMAP_ALL_FROZEN 0x02
#define VISIBILITYMAP_VALID_BITS 0x03

1.4 vmblock读写

vm_extend(Relation rel, BlockNumber vm_nblocks)
 PGAlignedBlock pg
 PageInit((Page) pg.data, BLCKSZ, 0)
 LockRelationForExtension(rel, ExclusiveLock)
 BlockNumber vm_nblocks_now = smgrnblocks（rel->rd_smgr, VISIBILITYMAP_FORKNUM）
 while vm_nblocks_now < vm_nblocks：
 PageSetChecksumInplace((Page) pg.data, vm_nblocks_now)
 smgrextend(rel->rd_smgr, VISIBILITYMAP_FORKNUM, vm_nblocks_now,
 pg.data, false)
 vm_nblocks_now++
 /* 让其他postgres进程smgrclose(rel) */
 CacheInvalidateSmgr(rel->rd_smgr->smgr_rnode) {
 SharedInvalidationMessage msg
 msg.sm.id = SHAREDINVALSMGR_ID;
 msg.sm.backend_hi = rnode.backend >> 16;
 msg.sm.backend_lo = rnode.backend & 0xffff;
 msg.sm.rnode = rnode.node;
 VALGRIND_MAKE_MEM_DEFINED(&msg, sizeof(msg))
 SendSharedInvalidMessages(&msg, 1)
 }
 rel->rd_smgr->smgr_vm_nblocks = vm_nblocks_now
 UnlockRelationForExtension(rel, ExclusiveLock)

Buffer
vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
 RelationOpenSmgr(rel)
 if blkno >= rel->rd_smgr->smgr_vm_nblocks:
 if extend:
 vm_extend(rel, blkno + 1)
 buf = ReadBufferExtended(rel , VISIBILITYMAP_FORKNUM, blkno,RBM_ZERO_ON_ERROR)
 if PageIsNew(buf):
 PageInit(buf, BLKSZ, 0)
 return buf

1.5 vm模块对外接口

void visibilitymap_set(Relation rel, BlockNumber heapBlk, Buffer heapBuf, XLogRecPtr recptr, Buffer vmBuf, TransactionId cutoff_xid, uint8 flags)
uint8 visibilitymap_get_status(Relation rel, BlockNumber heapBlk, Buffer *vmbuf)
bool visibilitymap_clear(Relation rel, BlockNumber heapBlk, Buffer vmbuf, uint8 flags)

/* 每个heapblock有3种状态 */
uint8
visibilitymap_get_status(Relation rel, BlockNumber heapBlk, Buffer *buf)
 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk)
 uint32 mapByte = HEAPBLK_TO_MAPBYTE(heapBlk)
 uint8 mapOffset = HEAPBLK_TO_OFFSET(heapBlk)

 /* 比较传入的buf和计算的mapblock是否为同一个 */
 if BufferIsValid(*buf):
 if BufferGetBlockNumber(*buf) != mapBlock:
 *buf = InvalidBuffer
 if !BufferIsValid(*buf):
 *buf = vm_readbuf(rel, mapBlock, false)

 map = PageGetContents(BufferGetPage(*buf))
 /* 每个heapbuf有01 10 11共3种状态 */
 unit8 result = ((map[mapByte] >> mapOffset) & VISIBILITYMAP_VALID_BITS)
 return uint8

void visibilitymap_set(Relation rel, BlockNumber heapBlk, Buffer heapBuf, XLogRecPtr recptr, Buffer vmBuf, TransactionId cutoff_xid, uint8 flags)
 ...

PostgreSQL 3-1 Heapam

Tue, 21 Jan 2025 13:55:00 +0800

1 heamp的简介

前置知识：Relation的基本概念，Tuple的基本概念

1.1 heapam接口的功能

heapam是存储模块对上层提供的数据读写接口，这些接口通常是操作1个relation中的1个或多个tuple。
本文介绍以下4个最常用的接口，即如何向1个relation中写入、删除、更新、读取1个Tuple，接口定义如下：

/* 向relatiion中写入1条tuple */
heap_insert(Relation relation, HeapTuple tup, ...)
/* 从relation中删除1条tuple */
heap_delete(Relation relation, ItemPointer tid, ...)
/* 在relation中，将旧tuple标记删除，并写入1个新tuple */
heap_update(Relation relation, ItemPointer otid, HeapTuple newtup, ...)
/* 从relation中读取数据，每次读取1条数据 */
HeapScanDesc heap_beginscan(Relation relation, ...)
HeapTuple heap_getnext(HeapScanDesc scan)

1.2 调用heapam接口

/*
 * 此处，以4个常见的SQL为例，介绍数据库如何调用heapam接口
 * 1. INSERT INTO t1 VALUES (1, 'data1');
 * 2. SELECT * FROM t1;
 * 3. DELETE FROM t1 WHERE c1 = 1;
 * 4. UPDATE t1 SET c2 = 'data2' WHERE c1 = 1;
 */
exec_simple_query("SQL语句") /* 该函数是所有SQL语句的统一处理入口 */
 PortalRun()
 PortalRunMulti()
 ProcessQuery()
 ExecutorRun()
 standard_ExecutorRun()
 ExecutePlan()
 ExecProcNode() /* 从这里开始分叉，不同类型的SQL语句，由不同函数处理 */
 ExecModifyTable()
 ExecInsert() /* 处理：INSERT INTO t1 VALUES (1, 'data1') */
 heap_insert(relation, tuple, ..)

1.3 heapam接口的使用场景

实际应用场景中，数据库的存储模块需满足以下关键需求：

PostgreSQL 3-8 Index

Tue, 21 Jan 2025 13:55:00 +0800

1 背景
1.1 数据检索
1 索引概述
1. 1.1 概述
2. 1.2 索引函数
  1. 1.2.1 调用索引函数
  2. 1.2.2 索引函数
2 索引实现
1. 2.1 创建索引 ambuild
  1. 一、build整体流程
  2. 二、build插入tuple
2. 2.2 索引写入数据 aminsert
3 operate

1 背景

1.1 数据检索

通常，应用会使用数据库存储大量数据，比如，单个表存储上百万、甚至上百亿条数据。此时，对表中数据进行某些查询时，将变得非常困难，比如等值查询、范围查询、模糊查询等。

1 索引概述

1.1 概述

索引方式：postgresql共有5种索引
- 唯一索引：不能出现重复的值
- 主键索引：主键自动创建唯一索引
- 多属性索引：多个列（最多32列）
- 部分索引：WHERE过滤索引
```
-- 示例
CREATE INDEX .. WHERE (c1 > 10);
```
- 表达式索引：和部分索引没太大区别，都是额外调用1个函数
```
-- 示例
CREATE INDEX .. WHERE (c1 = 10);
```
索引分类：postgresql有多种索引，本文见介绍以下4种
- btree
- hash
- gist
- gin

索引系统表

pg_am：存储所有索引的方法

SELECT * FROM pg_am;
 amname | amhandler | amtype
 -------+-------------+--------
 btree | bthandler | i
 hash | hashhandler | i
 gist | gisthandler | i
 gin | ginhandler | i
 spgist | spghandler | i
 brin | brinhandler | i

pg_index：存储所有索引，索引列的下标

PostgreSQL 3-9 Vacuum

Tue, 21 Jan 2025 13:55:00 +0800

1 概述

select reltuples,relhasoids,oid from pg_class where relname = 't1';
-- reltuples = 0
select pg_relation_filepath('t1');
-- oid = filepath = relfilenode

vacuum full t1;
select reltuples,relhasoids,oid from pg_class where relname = 't1';
-- oid 不变, reltuples = 0
-- oid != filepath = relfilenode !=

analyze t1;
-- reltuples = 2，即有效tuple

启动autovacuum进程

standard_ProcessUtility(Node *parsetree)
 case T_VacuumStmt:
 ExecVacuum(VacuumStmt *vacstmt)
 vacuum(RangeVar *relation, Oid relid, VacuumParams *params)

ServerLoop(void)
 StartAutoVacLauncher(void)
 AutoVacLauncherMain()
 /* if fail: 发送信号重启aotuvacuum进程 */
 SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_WORKER)

sigusr1_handler(SIGNAL_ARGS)
 if CheckPostmasterSignal(PMSIGNAL_START_AUTOVAC_WORKER):
 StartAutovacuumWorker(void)
 Backend *bn = malloc();
 bn->pid = StartAutoVacWorker(void)
 AutoVacWorkerMain(int argc, char *argv[])()
 BaseInit();
 InitPostgres(NULL, dbid, NULL, InvalidOid, dbname)
 do_autovacuum()
 autovacuum_do_vac_analyze(autovac_table *tab)
 vacuum(RangeVar *relation, Oid relid, VacuumParams *params)
 proc_exit(0)
 dlist_push_head(&BackendList, &bn->elem)

查找所有待vacuum的表

do_autovacuum(void) /* table-by-table */
 StartTransactionCommand()

 /* 查询pg_database系统表 */
 tuple = SearchSysCache1(DATABASEOID)

 /* 打开pg_class系统表 */
 classRel = heap_open(RelationRelationId)
 pg_class_desc = CreateTupleDescCopy(RelationGetDescr(classRel))

 /* 为toast表创建hash表 */
 table_toast_map = hash_create()

 /* 遍历pg_class系统表，记录所有需要vacuum和analyze的普通表和系统表 */
 relScan = heap_beginscan_catalog(classRel)
 while tuple = heap_getnext(relScan) != NULL:
 Form_pg_class classForm = (Form_pg_class) GETSTRUCT(tuple)
 relid = HeapTupleGetOid(tuple)

 relopts = extract_autovac_opts(tuple, pg_class_desc)
 tabentry = get_pgstat_tabentry_relid(relid, classForm->relisshared)
 /* 检查表是否需要被vacuum和analyze */
 relation_needs_vacanalyze(relid, relopts, classForm, tabentry, &dovacuum, &doanalyze)

 if dovacuum || doanalyze:
 /* 普通表加入list中 */
 table_oids = lappend_oid(table_oids, relid)

 /* toast表加入hash表中 */
 if OidIsValid(classForm->reltoastrelid):
 hentry = hash_search(table_toast_map, &classForm->reltoastrelid, HASH_ENTER)
 hentry->ar_relid = relid
 eap_endscan(relScan)

 /* 第二次遍历pg_class系统表 */
 relScan = heap_beginscan_catalog(classRel)
 while tuple = heap_getnext(relScan) != NULL:
 Form_pg_class classForm = (Form_pg_class) GETSTRUCT(tuple)
 relid = HeapTupleGetOid(tuple)

 relopts = extract_autovac_opts(tuple, pg_class_desc)
 ...

 bstrategy = GetAccessStrategy(BAS_VACUUM)

 /* 开始遍历所有list中的表 */
 foreach(cell, table_oids)
 Oid relid = lfirst_oid(cell)
 /* 再次检查是否仍需vacuum */
 tab = table_recheck_autovac(relid, table_toast_map, pg_class_desc)
 if tab == NULL:
 continue

 MyWorkerInfo->wi_tableoid = relid
 autovac_balance_cost()
 AutoVacuumUpdateDelay()

 autovacuum_do_vac_analyze(tab, bstrategy)

 vac_update_datfrozenxid()
 CommitTransactionCommand()

对单个表进行vacuum

PostgreSQL 3-13 逻辑复制测试记录

Thu, 21 May 2026 17:38:00 +0800

1 本地自测

1.1 快速tpcc

vkill
rm -rf $GAUSSHOME/data*
# cp -r ~/w100_t200/data $GAUSSHOME/data
# cp -r ~/w100_t200/data1 $GAUSSHOME/
cp -r ~/w5/data $GAUSSHOME/data
cp -r ~/w5/data1 $GAUSSHOME/
# cp -r ~/w100/data $GAUSSHOME/data
# cp -r ~/w100/data1 $GAUSSHOME/

# vb_guc set -D $GAUSSHOME/data -c "enable_ddl_logical_decode=on"
# vb_guc set -D $GAUSSHOME/data1 -c "enable_ddl_logical_decode=on"
# vb_guc set -D $GAUSSHOME/data1 -c "max_replication_slots=50"
# vb_guc set -D $GAUSSHOME/data1 -c "max_background_workers=50"
# vb_guc set -D $GAUSSHOME/data1 -c "max_logical_replication_workers=50"
vb_guc set -D $GAUSSHOME/data1 -c "max_connections=4000"

vb_guc set -D $GAUSSHOME/data1 -c "enable_audit=on"
vb_guc set -D $GAUSSHOME/data1 -c "audit_buffer_size=262144"
vb_guc set -D $GAUSSHOME/data1 -c "audit_directory_size=1073741824"

vb_ctl start -D $GAUSSHOME/data
vb_ctl start -D $GAUSSHOME/data1

# 五、发布端（发布）
vsql -d pubdb -p 64000 -c "CREATE PUBLICATION pub1 FOR all tables WITH (ddl='all');"
vsql -d pubdb -p 64000 -c " SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');"

# # 六、订阅端（订阅）
gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription

vsql -d pubdb -p 65000 -c "CREATE SUBSCRIPTION sub1 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=220);"
#
# vsql -d pubdb -p 65000 -r
# \q
# cd ~/tpcc
# source envbm
# ./toolbm run vpub

# 换窗口查询
vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()"
vsql -d pubdb -p 64000 -c "SELECT * FROM vb_parallel_apply_stat()"

vsql -d pubdb -p 64000 -c "SELECT * FROM vb_parallel_apply_stat()"

# 场景一：验证内存
vsql -d pubdb -p 64000 -c "SELECT * FROM gs_thread_memory_context ORDER BY totalsize DESC limit 30;" > start_pub.mem
vsql -d pubdb -p 64000 -c "SELECT * FROM gs_shared_memory_detail ORDER BY totalsize DESC limit 30;;" >> start_pub.mem

vsql -d pubdb -p 65000 -c "SELECT * FROM gs_thread_memory_context ORDER BY totalsize DESC limit 30;;" > start_sub.mem
vsql -d pubdb -p 65000 -c "SELECT * FROM gs_shared_memory_detail ORDER BY totalsize DESC limit 30;;" >> start_sub.mem

# 场景八：验证数据一致性
vsql -d pubdb -p 64000 -c "DROP TABLE IF EXISTS tcnt"
vsql -d pubdb -p 64000 -c "CREATE TABLE tcnt (c1 TEXT,c2 INT);"
vsql -d pubdb -p 65000 -c "DROP TABLE IF EXISTS tcnt"
vsql -d pubdb -p 65000 -c "CREATE TABLE tcnt (c1 TEXT,c2 INT);"

for t in bmsql_config bmsql_customer bmsql_district bmsql_history bmsql_item bmsql_new_order bmsql_oorder bmsql_order_line bmsql_stock bmsql_warehouse; do
 echo "$t"
 vsql -d pubdb -p 64000 -c "INSERT INTO tcnt VALUES('$t', (SELECT count(1) FROM $t));"
done;

for t in bmsql_config bmsql_customer bmsql_district bmsql_history bmsql_item bmsql_new_order bmsql_oorder bmsql_order_line bmsql_stock bmsql_warehouse; do
 echo "$t"
 vsql -d pubdb -p 65000 -c "INSERT INTO tcnt VALUES('$t', (SELECT count(1) FROM $t));"
done;

vsql -d pubdb -p 64000 -c "SELECT * FROM tcnt"
vsql -d pubdb -p 65000 -c "SELECT * FROM tcnt;"

# 场景一：重启订阅端（kill）
for i in $(seq 0 10);
do
 echo "$i------------------------------------------------------------------------------------"
 ps ux | grep 'vastbase.*-D.*/data1' | grep -v grep | awk '{print $2}' | xargs kill -9
 vb_ctl start -D $GAUSSHOME/data1
 sleep 7
 vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()" >> a.out
done;

# 场景二：重启订阅端(stop)
for i in $(seq 0 10);
do
 echo "$i------------------------------------------------------------------------------------"
 echo "$i------------------------------------------------------------------------------------" >> a.out
 vb_ctl stop -D $GAUSSHOME/data1
 vb_ctl start -D $GAUSSHOME/data1
 vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()" >> a.out
 sleep 7
 vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()" >> a.out
done;

# 场景三：重启发布端
vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()"
vb_ctl stop -D $GAUSSHOME/data
sleep 5
vb_ctl start -D $GAUSSHOME/data
vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()"

vb_ctl restart -D $GAUSSHOME/data1

# 场景三：重建 subscription
for i in $(seq 0 10);
do
 echo "$i------------------------------------------------------------------------------------"
 echo "$i------------------------------------------------------------------------------------" >> a.out
 vsql -d pubdb -p 65000 -c "DROP SUBSCRIPTION sub1;"
 vsql -d pubdb -p 64000 -c " SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');"
 vsql -d pubdb -p 65000 -c "CREATE SUBSCRIPTION sub1 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=20);"
 sleep 6
 vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()" >> a.out
done;

vsql -d pubdb -p 65000 -c "DROP SUBSCRIPTION sub1;"
vsql -d pubdb -p 64000 -c " SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');"
vsql -d pubdb -p 65000 -c "CREATE SUBSCRIPTION sub1 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=20);"
vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()"

vsql -d pubdb -p 65000 -c "SELECT * FROM pg_subscription_rel"
vsql -d pubdb -p 64000 -c "SELECT * FROM vb_parallel_apply_stat()"

SELECT pg_wal_lsn_diff(pg_current_wal_lsn(), '0/0') / (1024 * 1024);

# 场景五：ddl
vsql -d pubdb -p 64000 -c "\d"
vsql -d pubdb -p 65000 -c "\d"
vsql -d pubdb -p 64000 -c "DROP TABLE bmsql_warehouse"
vsql -d pubdb -p 64000 -c "CREATE TABLE t3(c1 INT)"
vsql -d pubdb -p 64000 -c "\d"
vsql -d pubdb -p 65000 -c "\d"

# 场景六：多个发布订阅
vsql -d postgres -p 64000 -c "CREATE DATABASE db3;"
vsql -d db3 -p 64000 -c "CREATE TABLE t3(c1 INT PRIMARY KEY, c2 TEXT);"
vsql -d db3 -p 64000 -c "CREATE PUBLICATION pub3 FOR all tables WITH (ddl='all');"
vsql -d db3 -p 64000 -c " SELECT pg_create_logical_replication_slot('pslot3', 'pgoutput');"

vsql -d postgres -p 65000 -c "CREATE DATABASE db3;"
vsql -d db3 -p 65000 -c "CREATE TABLE t3(c1 INT PRIMARY KEY, c2 TEXT);"
vsql -d db3 -p 65000 -c "CREATE SUBSCRIPTION sub3 CONNECTION 'host=172.16.103.90 port=64001 dbname=db3 user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub3 WITH (create_slot=false, slot_name = 'pslot3', copy_data = false, worker_number=20);"

vsql -d pubdb -p 65000 -c "DROP SUBSCRIPTION sub1;"

for i in $(seq 0 10); do vsql -d db3 -p 64000 -c "BEGIN; INSERT INTO t3 VALUES($i,'a'); UPDATE t3 SET c2='b' WHERE c1=$i-1; COMMIT;" & done; wait

# 跑10分钟
./toolbm run vpub

vsql -d pubdb -p 65000 -c "DROP SUBSCRIPTION sub1;"

#
for t in bmsql_config bmsql_customer bmsql_district bmsql_history bmsql_item bmsql_new_order bmsql_oorder bmsql_order_line bmsql_stock bmsql_warehouse; do
 echo "$t"
 vsql -d pubdb -p 65000 -c "TRUNCATE $t"
done;

续点重传

vkill
rm -rf $GAUSSHOME/data*
# cp -r ~/w5/data $GAUSSHOME/data
# cp -r ~/w5/data1 $GAUSSHOME/
cp -r ~/w100/data $GAUSSHOME/data
cp -r ~/w100/data1 $GAUSSHOME/

vb_guc set -D $GAUSSHOME/data1 -c "max_connections=4000"

vb_ctl start -D $GAUSSHOME/data
vb_ctl start -D $GAUSSHOME/data1

# 五、发布端（发布）
vsql -d pubdb -p 64000 -c "CREATE PUBLICATION pub1 FOR all tables WITH (ddl='all');"
vsql -d pubdb -p 64000 -c " SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');"

# # 六、订阅端（订阅）
gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription

vsql -d pubdb -p 65000 -c "CREATE SUBSCRIPTION sub1 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=220);"
#
# vsql -d pubdb -p 65000 -r
# \q

vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()"
vsql -d pubdb -p 64000 -c "SELECT * FROM vb_parallel_apply_stat()"

# ./toolbm run vpub

# 重启订阅端（kill）
for i in $(seq 0 10);
do
 echo "$i------------------------------------------------------------------------------------"
 ps ux | grep 'vastbase.*-D.*/data1' | grep -v grep | awk '{print $2}' | xargs kill -9
 vb_ctl start -D $GAUSSHOME/data1
 sleep 7
 vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()" >> a.out
done;

vsql -d pubdb -p 64000 -c " SELECT * FROM pg_get_replication_slots(); "
vsql -d pubdb -p 64000 -c " SELECT pg_current_wal_lsn();"

# 验证数据一致性
vsql -d pubdb -p 64000 -c "DROP TABLE IF EXISTS tcnt"
vsql -d pubdb -p 64000 -c "CREATE TABLE tcnt (c1 TEXT,c2 INT);"
vsql -d pubdb -p 65000 -c "DROP TABLE IF EXISTS tcnt"
vsql -d pubdb -p 65000 -c "CREATE TABLE tcnt (c1 TEXT,c2 INT);"

for t in bmsql_config bmsql_customer bmsql_district bmsql_history bmsql_item bmsql_new_order bmsql_oorder bmsql_order_line bmsql_stock bmsql_warehouse; do
 echo "$t"
 vsql -d pubdb -p 64000 -c "INSERT INTO tcnt VALUES('$t', (SELECT count(1) FROM $t));"
done;

for t in bmsql_config bmsql_customer bmsql_district bmsql_history bmsql_item bmsql_new_order bmsql_oorder bmsql_order_line bmsql_stock bmsql_warehouse; do
 echo "$t"
 vsql -d pubdb -p 65000 -c "INSERT INTO tcnt VALUES('$t', (SELECT count(1) FROM $t));"
done;

vsql -d pubdb -p 64000 -c "SELECT * FROM tcnt"
vsql -d pubdb -p 65000 -c "SELECT * FROM tcnt;"

-- ===================== worker_number =======================
CREATE SUBSCRIPTION sub1 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false);
DROP SUBSCRIPTION sub1;
\! vsql -d pubdb -p 64000 -c " SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');"

CREATE SUBSCRIPTION sub2 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=1);
DROP SUBSCRIPTION sub2;
\! vsql -d pubdb -p 64000 -c " SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');"

CREATE SUBSCRIPTION sub3 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=2);
DROP SUBSCRIPTION sub3;
\! vsql -d pubdb -p 64000 -c " SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');"

CREATE SUBSCRIPTION sub4 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=200);
DROP SUBSCRIPTION sub4;
\! vsql -d pubdb -p 64000 -c " SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');"

CREATE SUBSCRIPTION sub5 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=400);
DROP SUBSCRIPTION sub5;

CREATE SUBSCRIPTION sub6 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=1000);
DROP SUBSCRIPTION sub6;

-- ===================== copy_data =======================
-- do truncate fist
CREATE SUBSCRIPTION sub21 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = true, worker_number=50);
SELECT * FROM pg_subscription_rel;
DROP SUBSCRIPTION sub21;

-- copy and stop

-- ===================== cache file =======================
-- 1. drop subscription
-- 2. kill progress

-- ===================== 断点续传 =======================

vsql -d postgres -p 50000 -c "DROP TABLE IF EXISTS t1"
vsql -d postgres -p 50000 -c "CREATE TABLE t1(c1 INT, c2 TEXT)"

for i in $(seq 0 10); do vsql -d postgres -p 50000 -c "BEGIN; INSERT INTO t1 VALUES($i,'a'); UPDATE t1 SET c2='b' WHERE c1=$i-1; COMMIT;" & done

vsql -d postgres -p 50000 -c "SELECT * FROM t1 ORDER BY c1"

parallel_apply.source

1 自测

批量验证

初始化模板

export VDATA=~/g100/rep/data

vb_guc set -D $VDATA -c "port=64000"
vb_guc set -D $VDATA -c "max_connection=2000"
vb_guc set -D $VDATA -c "wal_level=logical"
vb_guc set -D $VDATA -c "max_replication_slots=100"
vb_guc set -D $VDATA -c "max_background_workers=100"
vb_guc set -D $VDATA -c "max_logical_replication_workers=100"
sed -i '1i host all all 0.0.0.0/0 sha256\n' $VDATA/pg_hba.conf
echo "host replication all 0.0.0.0/0 sha256" >> $VDATA/pg_hba.conf

insert性能

export VDATA=~/g100/rep/data

vkill
rm -rf ~/g100/rep/data
cp -r ~/g100/rep/temp ~/g100/rep/data
vstart

vsql -d postgres -p 64000 -r
-- 3 create publicatioin
\c postgres
CREATE DATABASE pubdb;
\c pubdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
CREATE PUBLICATION pub1 FOR all tables;
CREATE USER pu1 REPLICATION SYSADMIN LOGIN ENCRYPTED PASSWORD 'pu1.12345';
SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');

-- sub
CREATE DATABASE subdb;
\c subdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
\! gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription
CREATE SUBSCRIPTION sub1 CONNECTION 'host=127.0.0.1 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name='pslot1', copy_data=false, worker_number=80);

SELECT count(1) FROM t1;
SELECT * FROM vb_parallel_apply_stat();

\c pubdb
truncate t1;
\c subdb
truncate t1;

SELECT datname,state,length(query) FROM pg_stat_activity WHERE datname = 'pubdb';

多个发布订阅


vb_guc set -D ~/g100/rep/data -c "max_replication_slots=256"
vb_guc set -D ~/g100/rep/data -c "max_background_workers=256"
vb_guc set -D ~/g100/rep/data -c "max_logical_replication_workers=256"

export VDATA=~/g100/rep/data

vkill
rm -rf ~/g100/rep/data
cp -r ~/g100/rep/temp ~/g100/rep/data
vb_guc set -D ~/g100/rep/data -c "enable_ddl_logical_decode=on"
vb_guc set -D ~/g100/rep/data -c "max_wal_senders=36"
vb_guc set -D ~/g100/rep/data -c "max_replication_slots=256"
vb_guc set -D ~/g100/rep/data -c "max_background_workers=256"
vb_guc set -D ~/g100/rep/data -c "max_logical_replication_workers=256"
vb_guc set -D ~/g100/rep/data -c "max_connections=1000"
vstart

rm -rf ~/g100/rep/data1
vb_guc set -D ~/g100/rep/data1 -c "port=65000"
cp -r ~/g100/rep/temp ~/g100/rep/data1
vb_ctl start -D ~/g100/rep/data1

# 发布
vsql -d postgres -p 64000 -c "CREATE USER pu1 REPLICATION SYSADMIN LOGIN ENCRYPTED PASSWORD 'pu1.12345';"
for i in $(seq 0 11);
do
 vsql -d postgres -p 64000 -c "CREATE DATABASE pubdb$i;"
 vsql -d pubdb$i -p 64000 -c "CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);"
 vsql -d pubdb$i -p 64000 -c "CREATE PUBLICATION pub$i FOR all tables;"
 vsql -d pubdb$i -p 64000 -c "SELECT pg_create_logical_replication_slot('pslot$i', 'pgoutput');"
done;

# 5 load data
for i in $(seq 0 11);
do
 for j in $(seq 0 10);
 do
 vsql -d pubdb$i -p 64000 -c "BEGIN; INSERT INTO t1 VALUES($j,'a'); UPDATE t1 SET c2='b' WHERE c1=$j-1; COMMIT;" &
 done;
 sleep 2
done; wait

# 订阅
gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription

for i in $(seq 0 11);
do
 vsql -d postgres -p 65000 -c "CREATE DATABASE subdb$i;"
 vsql -d subdb$i -p 65000 -c "CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);"
 vsql -d subdb$i -p 65000 -c "CREATE SUBSCRIPTION sub$i CONNECTION 'host=127.0.0.1 port=64001 dbname=pubdb$i user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub$i WITH (create_slot=false, slot_name = 'pslot$i', copy_data = false, worker_number=30);"
done;

sleep 5

# 6 check
for i in $(seq 0 11);
do
 vsql -d pubdb$i -p 64000 -c "SELECT count(1) FROM t1"
done;

for i in $(seq 0 11);
do
 vsql -d subdb$i -p 65000 -c "SELECT count(1) FROM t1"
done;

vsql -d postgres -p 64000 -c " SELECT * FROM pg_get_replication_slots();"

vsql -d postgres -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()"

# 7 cleanup
DROP SUBSCRIPTION sub1;
\c postgres
DROP DATABASE IF EXISTS pubdb;
DROP DATABASE IF EXISTS subdb;
DROP USER pu1;

copydata

export VDATA=~/g100/rep/data

vkill
rm -rf ~/g100/rep/data
cp -r ~/g100/rep/temp ~/g100/rep/data
vstart

rm -rf ~/g100/rep/data1
cp -r ~/g100/rep/temp ~/g100/rep/data1
vb_guc set -D ~/g100/rep/data1 -c "port=65000"
vb_ctl start -D ~/g100/rep/data1

vsql -d postgres -p 64000 -r
-- 3 create publicatioin
-- pub
\c postgres
CREATE DATABASE pubdb;
\c pubdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
CREATE PUBLICATION pub1 FOR all tables;
-- CREATE PUBLICATION pub1 FOR TABLE t1,t2;
CREATE USER pu1 REPLICATION SYSADMIN LOGIN ENCRYPTED PASSWORD 'pu1.12345';
-- INSERT INTO t1 VALUES(1,'a'),(2,'b'),(3,'c');
-- INSERT INTO t1 (c1,c2) SELECT i,'BASE_' || i || '_' || repeat('X', 13000) FROM generate_series(1, 10000) AS i;
\q

-- for i in $(seq 0 1000); do vsql -d pubdb -p 64000 -c "INSERT INTO t1 VALUES($i,'a'); " ; done

vsql -d postgres -p 65000 -r
-- sub
CREATE DATABASE subdb;
\c subdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
\! gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription
CREATE SUBSCRIPTION sub1 CONNECTION 'host=127.0.0.1 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (copy_data=false, worker_number=10);

-- \! for i in $(seq 20000 20010); do vsql -d pubdb -p 64000 -c "INSERT INTO t1 VALUES($i,'a'); " ; done

SELECT * FROM t1;
SELECT * FROM vb_parallel_apply_stat();

vsql -d pubdb -p 64000 -c "SELECT count(1) FROM t1"
vsql -d subdb -p 65000 -c "SELECT count(1) FROM t1"
vsql -d subdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()"

SELECT * FROM pg_replication_slots;

INSERT INTO t1 VALUES(4,'a'),(5,'b'),(6,'c');

ddl

export VDATA=~/g100/rep/data

vkill
rm -rf ~/g100/rep/data
cp -r ~/g100/rep/temp ~/g100/rep/data
vb_guc set -D ~/g100/rep/data -c "enable_ddl_logical_decode=on"
vstart

rm -rf ~/g100/rep/data1
cp -r ~/g100/rep/temp ~/g100/rep/data1
vb_guc set -D ~/g100/rep/data1 -c "port=65000"
vb_ctl start -D ~/g100/rep/data1

vsql -d postgres -p 64000 -r
-- 3 create publicatioin
-- pub
\c postgres
CREATE DATABASE pubdb;
\c pubdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
CREATE PUBLICATION pub1 FOR all tables WITH (publish='insert,update,delete,truncate', ddl='all');
-- CREATE PUBLICATION pub1 FOR TABLE t1,t2;
CREATE USER pu1 REPLICATION SYSADMIN LOGIN ENCRYPTED PASSWORD 'pu1.12345';
-- INSERT INTO t1 VALUES(1,'a'),(2,'b'),(3,'c');
\q

vsql -d postgres -p 65000 -r
-- sub
CREATE DATABASE subdb;
\c subdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
\! gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription
CREATE SUBSCRIPTION sub1 CONNECTION 'host=127.0.0.1 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (copy_data=true, worker_number=4);

SELECT * FROM t1;

\! vsql -d pubdb -p 64000 -c "TRUNCATE t1"
\! sleep 1
SELECT * FROM t1;

\! vsql -d pubdb -p 64000 -c "DROP TABLE t1"
\! sleep 1
SELECT * FROM t1;

SELECT * FROM pg_replication_slots;

INSERT INTO t1 VALUES(4,'a'),(5,'b'),(6,'c');

sub-txn + ddl

export VDATA=~/g100/rep/data

vkill
rm -rf ~/g100/rep/data
cp -r ~/g100/rep/temp ~/g100/rep/data
vb_guc set -D ~/g100/rep/data -c "enable_ddl_logical_decode=on"
vstart

rm -rf ~/g100/rep/data1
cp -r ~/g100/rep/temp ~/g100/rep/data1
vb_guc set -D ~/g100/rep/data1 -c "port=65000"
vb_ctl start -D ~/g100/rep/data1

vsql -d postgres -p 64000 -r
-- 3 create publicatioin
-- pub
\c postgres
CREATE DATABASE pubdb;
\c pubdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
CREATE PUBLICATION pub1 FOR all tables WITH (publish='insert,update,delete,truncate', ddl='all');
-- CREATE PUBLICATION pub1 FOR TABLE t1,t2;
CREATE USER pu1 REPLICATION SYSADMIN LOGIN ENCRYPTED PASSWORD 'pu1.12345';
INSERT INTO t1 VALUES(1,'a'),(2,'b'),(3,'c');
\q

vsql -d postgres -p 65000 -r
-- sub
CREATE DATABASE subdb;
\c subdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
\! gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription
CREATE SUBSCRIPTION sub1 CONNECTION 'host=127.0.0.1 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (copy_data=true, worker_number=4);

SELECT * FROM t1;

\! vsql -d pubdb -p 64000 -c "TRUNCATE t1"
\! sleep 1
SELECT * FROM t1;

\! vsql -d pubdb -p 64000 -c "DROP TABLE t1"
\! sleep 1
SELECT * FROM t1;

\! vsql -d pubdb -p 64000 -c "BEGIN; CREATE TABLE t3(c1 int); SAVEPOINT sp1; INSERT INTO t3 VALUES(3); SAVEPOINT sp2; TRUNCATE t3; SAVEPOINT sp3; COMMIT;"
SELECT * FROM t3;
DROP TABLE t3;
SELECT * FROM pg_replication_slots;

INSERT INTO t1 VALUES(4,'a'),(5,'b'),(6,'c');

disable

export VDATA=~/g100/rep/data

vkill
rm -rf ~/g100/rep/data
cp -r ~/g100/rep/temp ~/g100/rep/data
vstart

rm -rf ~/g100/rep/data1
cp -r ~/g100/rep/temp ~/g100/rep/data1
vb_guc set -D ~/g100/rep/data1 -c "port=65000"
vb_ctl start -D ~/g100/rep/data1

vsql -d postgres -p 64000 -r
-- 3 create publicatioin
-- pub
\c postgres
CREATE DATABASE pubdb;
\c pubdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
CREATE PUBLICATION pub1 FOR all tables WITH (ddl='all');
-- CREATE PUBLICATION pub1 FOR TABLE t1,t2;
CREATE USER pu1 REPLICATION SYSADMIN LOGIN ENCRYPTED PASSWORD 'pu1.12345';
INSERT INTO t1 VALUES(1,'a'),(2,'b'),(3,'c');
\q

vsql -d postgres -p 65000 -r
-- sub
CREATE DATABASE subdb;
\c subdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
\! gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription
CREATE SUBSCRIPTION sub1 CONNECTION 'host=127.0.0.1 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (copy_data=true, worker_number=4);

SELECT * FROM t1;
-- SELECT * FROM pg_replication_slots;
SELECT * FROM pg_stat_subscription;
ALTER SUBSCRIPTION sub1 DISABLE;
\! vsql -d pubdb -p 64000 -c "INSERT INTO t1 VALUES(4,'a'),(5,'b'),(6,'c');"
SELECT * FROM t1;

ALTER SUBSCRIPTION sub1 ENABLE;
SELECT * FROM pg_replication_slots;

基础场景

vkill
vinit
-- 1 config
vb_guc set -D $GAUSSHOME/data -c "wal_level=logical"
vb_guc set -D $GAUSSHOME/data -c "max_replication_slots=100"
vb_guc set -D $GAUSSHOME/data -c "max_background_workers=100"
vb_guc set -D $GAUSSHOME/data -c "max_logical_replication_workers=100"
sed -i '1i host all all 0.0.0.0/0 sha256\n' $GAUSSHOME/data/pg_hba.conf
echo "host replication all 0.0.0.0/0 sha256" >> $GAUSSHOME/data/pg_hba.conf

-- 2 startup
vstart
vsql -d postgres -p 50000 -r

-- 3 create publicatioin
\c postgres
CREATE DATABASE pubdb;
\c pubdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
CREATE PUBLICATION pub1 FOR all tables;
SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');
CREATE USER pu1 REPLICATION SYSADMIN LOGIN ENCRYPTED PASSWORD 'pu1.12345';

-- 4 create subscription
CREATE DATABASE subdb;
\c subdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
\! gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription
\! vsql -d subdb -p 50000 -c "CREATE SUBSCRIPTION sub1 CONNECTION 'host=127.0.0.1 port=50001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false);"
-- , worker_number=30
-- 172.16.103.90

\c pubdb
INSERT INTO t1 VALUES(1,'a'),(2,'b'),(3,'c');
UPDATE t1 SET c1 = 2 WHERE c2 = 'c';
INSERT INTO t1 VALUES(4,'d');

BEGIN;
INSERT INTO t1 VALUES(5,'e');
UPDATE t1 SET c1 = 1 WHERE c2 = 'b';
INSERT INTO t1 VALUES(6,'f');
COMMIT;

BEGIN;
INSERT INTO t1 VALUES(7,'d');
UPDATE t1 SET c2 = 'a' WHERE c1 = 2;
COMMIT;

-- 5 load data
\! for i in $(seq 0 10); do vsql -d pubdb -p 50000 -c "BEGIN; INSERT INTO t1 VALUES($i,'a'); UPDATE t1 SET c2='b' WHERE c1=$i-1; COMMIT;" > /dev/null 2>&1 & done; wait

\! sleep 3
-- 5 check subscription
\o pubdb.out
\c pubdb
SELECT * FROM t1 ORDER BY c1;
\o

\o subdb.out
\c subdb
SELECT * FROM t1 ORDER BY c1;
\o

\! grep -Irn "rows" pubdb.out
\! grep -Irn "rows" subdb.out
\! diff pubdb.out subdb.out
\! cat subdb.out

\! rm -f pubdb.out subdb.out

-- 7 cleanup
DROP SUBSCRIPTION sub1;
\c postgres
DROP DATABASE IF EXISTS pubdb;
DROP DATABASE IF EXISTS subdb;
DROP USER pu1;

空库feedback

vkill
rm -rf $GAUSSHOME/data*
cp -r ~/w5/data $GAUSSHOME/data
cp -r ~/w5/data1 $GAUSSHOME/

vb_guc set -D $GAUSSHOME/data1 -c "max_connections=4000"

vb_ctl start -D $GAUSSHOME/data
vb_ctl start -D $GAUSSHOME/data1

# 五、发布端（发布）
vsql -d pubdb -p 64000 -c "CREATE PUBLICATION pub1 FOR all tables WITH (ddl='all');"
vsql -d pubdb -p 64000 -c " SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');"

vsql -d pubdb -p 64000 -c "CREATE DATABASE db1";
vsql -d pubdb -p 64000 -c "CREATE DATABASE db2";
vsql -d db1 -p 64000 -c "CREATE PUBLICATION p1 FOR all tables WITH (ddl='all');"
vsql -d db1 -p 64000 -c " SELECT pg_create_logical_replication_slot('ps1', 'pgoutput');"
vsql -d db2 -p 64000 -c "CREATE PUBLICATION p2 FOR all tables WITH (ddl='all');"
vsql -d db2 -p 64000 -c " SELECT pg_create_logical_replication_slot('ps2', 'pgoutput');"

# 六、订阅端（订阅）
gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription
vsql -d pubdb -p 65000 -c "CREATE SUBSCRIPTION sub1 CONNECTION 'host=172.16.103.90 port=64001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=220);"

vsql -d pubdb -p 65000 -c "CREATE DATABASE db1";
vsql -d pubdb -p 65000 -c "CREATE DATABASE db2";
vsql -d db1 -p 65000 -c "CREATE SUBSCRIPTION s1 CONNECTION 'host=172.16.103.90 port=64001 dbname=db1 user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION p1 WITH (create_slot=false, slot_name = 'ps1', copy_data = false, worker_number=220);"
vsql -d db2 -p 65000 -c "CREATE SUBSCRIPTION s2 CONNECTION 'host=172.16.103.90 port=64001 dbname=db2 user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION p2 WITH (create_slot=false, slot_name = 'ps2', copy_data = false, worker_number=220);"

vsql -d pubdb -p 64000 -c "CREATE VIEW pstat AS SELECT slot_name,active,confirmed_flush, (pg_wal_lsn_diff(confirmed_flush, '0/0') / (1024 * 1024))::int as confirmed_lsn FROM pg_get_replication_slots();"

# 查看复制进度
vsql -d pubdb -p 64000 -c "SELECT * FROM pstat"

# 查看速度
vsql -d pubdb -p 64000 -c "SELECT (pg_wal_lsn_diff(pg_current_wal_lsn(), '0/0') / (1024 * 1024))::int as mb"

vsql -d pubdb -p 65000 -c "SELECT * FROM vb_parallel_apply_stat()"
vsql -d pubdb -p 64000 -c "SELECT * FROM vb_parallel_apply_stat()"

子事务

1. 这是一个基于opengauss开发的数据
2. 我已经设置了一些alias命令。全量编译vcmake。增量编译：vrecmake。启动集群：vinit, vstart。强制停止集群：vkill。
3. core文件目录：/data/
4. 并行逻辑复制关键代码：parallel_apply.cpp
5. $GAUSSHOME也就是install目录下，所有文件都是临时生成的，随便动

vkill
vinit
-- 1 config
vb_guc set -D $GAUSSHOME/data -c "wal_level=logical"
vb_guc set -D $GAUSSHOME/data -c "max_replication_slots=100"
vb_guc set -D $GAUSSHOME/data -c "max_background_workers=100"
vb_guc set -D $GAUSSHOME/data -c "max_logical_replication_workers=100"
# vb_guc set -D $GAUSSHOME/data -c "enable_audit=on"
# vb_guc set -D $GAUSSHOME/data -c "audit_buffer_size=262144"
# vb_guc set -D $GAUSSHOME/data -c "audit_directory_size=1073741824"
sed -i '1i host all all 0.0.0.0/0 sha256\n' $GAUSSHOME/data/pg_hba.conf
echo "host replication all 0.0.0.0/0 sha256" >> $GAUSSHOME/data/pg_hba.conf

-- 2 startup
vstart
vsql -d postgres -p 50000 -r

-- 3 create publicatioin
\c postgres
CREATE DATABASE pubdb;
\c pubdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
CREATE PUBLICATION pub1 FOR all tables;
SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');
CREATE USER pu1 REPLICATION SYSADMIN LOGIN ENCRYPTED PASSWORD 'pu1.12345';

-- 4 create subscription
CREATE DATABASE subdb;
\c subdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
\! gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription

\! vsql -d subdb -p 50000 -c "CREATE SUBSCRIPTION sub1 CONNECTION 'host=127.0.0.1 port=50001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=20);"
-- , worker_number=30
-- 172.16.103.90

\c pubdb
BEGIN;
INSERT INTO t1 VALUES(1,'111'); -- 假如xid=1
SAVEPOINT s1;
INSERT INTO t1 VALUES(2,'222'); -- 假如xid=2 [savepoint 2, xid:1-2]
SAVEPOINT s2;

INSERT INTO t1 VALUES(3,'333'); -- 假如xid=3 [savepoint 3, xid:1-2-3]
SAVEPOINT s3;
INSERT INTO t1 VALUES(4,'444'); -- 假如xid=4 [savepoint 4, xid:1-2-3-4]
SAVEPOINT s4;
INSERT INTO t1 VALUES(5,'555'); -- 假如xid=5 [savepoint 5, xid:1-2-3-4-5]
ROLLBACK TO SAVEPOINT s2;

INSERT INTO t1 VALUES(6,'666'); -- 假如xid=6 [rollback to 3: xid:1-2]
SAVEPOINT s5;
INSERT INTO t1 VALUES(7,'777'); -- 假如xid=7
RELEASE SAVEPOINT s2; -- 此时，xid=6和xid=7会归并到xid=2的事务中

INSERT INTO t1 VALUES(8,'888'); -- 假如xid=2（假设上面RELEASE到s1，则xid=1，和顶层事务一致）
COMMIT;

-- \! sleep 3
-- 5 check subscription
\c pubdb
SELECT xmin,* FROM t1 ORDER BY c1;
\c subdb
SELECT * FROM vb_parallel_apply_stat();

SELECT xmin,* FROM t1 ORDER BY c1;

-- rollback to top
\c pubdb
BEGIN;
INSERT INTO t2 VALUES(1,'111'); -- 假如xid=1
SAVEPOINT s1;
INSERT INTO t2 VALUES(2,'222'); -- 假如xid=2
SAVEPOINT s2;

INSERT INTO t2 VALUES(3,'333'); -- 假如xid=3
SAVEPOINT s3;
INSERT INTO t2 VALUES(4,'444'); -- 假如xid=4
SAVEPOINT s4;
INSERT INTO t2 VALUES(5,'555'); -- 假如xid=5
ROLLBACK TO SAVEPOINT s2;

INSERT INTO t2 VALUES(6,'666'); -- 假如xid=6
SAVEPOINT s5;
INSERT INTO t2 VALUES(7,'777'); -- 假如xid=7
RELEASE SAVEPOINT s1; -- 此时，xid=6和xid=7会归并到xid=2的事务中

INSERT INTO t2 VALUES(8,'888'); -- 假如xid=2（假设上面RELEASE到s1，则xid=1，和顶层事务一致）
COMMIT;

-- \! sleep 3
-- 5 check subscription
\c pubdb
SELECT xmin,* FROM t2 ORDER BY c1;
\c subdb
SELECT xmin,* FROM t2 ORDER BY c1;

SELECT * FROM vb_parallel_apply_stat();

-- 延时检查
CREATE TABLE t3 (c1 INT, c2 TEXT );
ALTER TABLE t3 ADD CONSTRAINT t3_c1_unique UNIQUE (c1) DEFERRABLE;

-- 事务1 -- 事务2
BEGIN;
INSERT INTO t3 VALUES (1, 'a');
 BEGIN;
 SET CONSTRAINTS ALL DEFERRED;
 INSERT INTO t3 VALUES (1, 'a');
COMMIT;
 COMMIT;

-- 7 cleanup
DROP SUBSCRIPTION sub1;
\c postgres
DROP DATABASE IF EXISTS pubdb;
DROP DATABASE IF EXISTS subdb;
DROP USER pu1;

子事务 + 主键冲突

vkill
vinit
-- 1 config
vb_guc set -D $GAUSSHOME/data -c "wal_level=logical"
vb_guc set -D $GAUSSHOME/data -c "max_replication_slots=100"
vb_guc set -D $GAUSSHOME/data -c "max_background_workers=100"
vb_guc set -D $GAUSSHOME/data -c "max_logical_replication_workers=100"
sed -i '1i host all all 0.0.0.0/0 sha256\n' $GAUSSHOME/data/pg_hba.conf
echo "host replication all 0.0.0.0/0 sha256" >> $GAUSSHOME/data/pg_hba.conf

-- 2 startup
vstart
vsql -d postgres -p 50000 -r

-- 3 create publicatioin
\c postgres
CREATE DATABASE pubdb;
\c pubdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
CREATE PUBLICATION pub1 FOR all tables;
SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');
CREATE USER pu1 REPLICATION SYSADMIN LOGIN ENCRYPTED PASSWORD 'pu1.12345';

-- 4 create subscription
CREATE DATABASE subdb;
\c subdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
\! gs_guc generate -S 'pu1.12345' -D $GAUSSHOME/bin -o subscription

CREATE SUBSCRIPTION sub1 CONNECTION 'host=127.0.0.1 port=50001 dbname=pubdb user=pu1 password=pu1.12345 sslmode=disable' PUBLICATION pub1 WITH (create_slot=false, slot_name = 'pslot1', copy_data = false, worker_number=20);

INSERT INTO t1 VALUES(3,'old');

\c pubdb
BEGIN;
INSERT INTO t1 VALUES(1,'111'); -- 假如xid=1
SAVEPOINT s1;
INSERT INTO t1 VALUES(2,'222'); -- 假如xid=2 [savepoint 2, xid:1-2]
SAVEPOINT s2;
INSERT INTO t1 VALUES(3,'333'); -- 假如xid=3 [savepoint 3, xid:1-2-3]
SAVEPOINT s3;
INSERT INTO t1 VALUES(4,'444'); -- 假如xid=4 [savepoint 4, xid:1-2-3-4]
SAVEPOINT s4;
COMMIT;

\c subdb
SELECT * FROM t1;

SELECT * FROM vb_parallel_apply_stat();

-- 7 cleanup
DROP SUBSCRIPTION sub1;
\c postgres
DROP DATABASE IF EXISTS pubdb;
DROP DATABASE IF EXISTS subdb;
DROP USER pu1;

子事务开发

-- 子事务开发
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);

SELECT pg_current_wal_lsn();

-- 场景一：relase commit
BEGIN;
INSERT INTO t1 VALUES(1,'111'); -- 假如xid=1
SAVEPOINT s1;
INSERT INTO t1 VALUES(2,'222'); -- 假如xid=2
SAVEPOINT s2;

INSERT INTO t1 VALUES(3,'333'); -- 假如xid=3
SAVEPOINT s3;
INSERT INTO t1 VALUES(4,'444'); -- 假如xid=4
SAVEPOINT s4;
INSERT INTO t1 VALUES(5,'555'); -- 假如xid=5
ROLLBACK TO SAVEPOINT s2;

INSERT INTO t1 VALUES(6,'666'); -- 假如xid=6
SAVEPOINT s5;
INSERT INTO t1 VALUES(7,'777'); -- 假如xid=7
RELEASE SAVEPOINT s2; -- 此时，xid=6和xid=7会归并到xid=2的事务中

INSERT INTO t1 VALUES(8,'888'); -- 假如xid=2（假设上面RELEASE到s1，则xid=1，和顶层事务一致）

COMMIT;

SELECT xmin,* FROM t1 ORDER BY c1;

\! pg_xlogdump -p $GAUSSHOME/data/pg_xlog -s xxx -x xid

-- 场景二：release abort
BEGIN;
INSERT INTO t1 VALUES(1,'111'); -- 假如xid=1
SAVEPOINT s1;
INSERT INTO t1 VALUES(2,'222'); -- 假如xid=2
SAVEPOINT s2;

INSERT INTO t1 VALUES(3,'333'); -- 假如xid=3
SAVEPOINT s3;
INSERT INTO t1 VALUES(4,'444'); -- 假如xid=4
SAVEPOINT s4;
INSERT INTO t1 VALUES(5,'555'); -- 假如xid=5
ROLLBACK TO SAVEPOINT s2;

INSERT INTO t1 VALUES(6,'666'); -- 假如xid=6
SAVEPOINT s5;
INSERT INTO t1 VALUES(7,'777'); -- 假如xid=7
RELEASE SAVEPOINT s2; -- 此时，xid=6和xid=7会归并到xid=2的事务中

INSERT INTO t1 VALUES(8,'888'); -- 假如xid=2（假设上面RELEASE到s1，则xid=1，和顶层事务一致）

ROLLBACK TO SAVEPOINT s1;

COMMIT;

SELECT xmin,* FROM t1 ORDER BY c1;

-- pg 用例
echo "
wal_level=logical
max_worker_processes=20
max_logical_replication_workers=20
max_parallel_apply_workers_per_subscription=10 " >> $PG_HOME/data/postgresql.conf

\c postgres
CREATE DATABASE pubdb;
CREATE DATABASE subdb;

\c pubdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
CREATE PUBLICATION pub1 FOR ALL TABLES;
CREATE USER pu1 REPLICATION LOGIN PASSWORD 'pu1.12345';
SELECT pg_create_logical_replication_slot('pslot1', 'pgoutput');

-- 2 create subscription
\c subdb
CREATE TABLE t1(c1 INT PRIMARY KEY, c2 TEXT);
CREATE TABLE t2(c1 INT PRIMARY KEY, c2 TEXT);
CREATE SUBSCRIPTION sub1
CONNECTION 'host=127.0.0.1 port=5432 dbname=pubdb user=pu1 password=pu1.12345 replication=database'
PUBLICATION pub1
WITH (
 create_slot=false,
 slot_name='pslot1',
 copy_data=false,
 streaming=parallel
);

-- 3 test transaction
-- \c pubdb
-- BEGIN;
-- INSERT INTO t1 VALUES(1,'111'); -- top xid
-- SAVEPOINT s1;
-- INSERT INTO t1 VALUES(2,'222'); -- subxid 2
-- SAVEPOINT s2;
-- INSERT INTO t1 VALUES(3,'333'); -- subxid 3
-- SAVEPOINT s3;
-- INSERT INTO t1 VALUES(4,'444'); -- subxid 4
-- SAVEPOINT s4;
-- INSERT INTO t1 VALUES(5,'555'); -- subxid 5
-- ROLLBACK TO SAVEPOINT s2;
-- INSERT INTO t1 VALUES(6,'666'); -- subxid 6
-- SAVEPOINT s5;
-- INSERT INTO t1 VALUES(7,'777'); -- subxid 7
-- RELEASE SAVEPOINT s2;
-- INSERT INTO t1 VALUES(8,'888'); -- 回到s1对应事务上下文
-- COMMIT;

\c pubdb
BEGIN;
INSERT INTO t1 VALUES(1,'111'); -- 假如xid=1
SAVEPOINT s1;
INSERT INTO t1 VALUES(2,'222'); -- 假如xid=2
SAVEPOINT s2;
INSERT INTO t1 VALUES(3,'333'); -- 假如xid=3
SAVEPOINT s3;
INSERT INTO t1 VALUES(4,'444'); -- 假如xid=4
SAVEPOINT s4;
INSERT INTO t1 VALUES(5,'555'); -- 假如xid=5
ROLLBACK TO SAVEPOINT s2;
INSERT INTO t1 VALUES(6,'666'); -- 假如xid=6
SAVEPOINT s5;
INSERT INTO t1 VALUES(7,'777'); -- 假如xid=7
RELEASE SAVEPOINT s2; -- 此时，xid=6和xid=7会归并到xid=2的事务中
INSERT INTO t1 VALUES(8,'888'); -- 假如xid=2（假设上面RELEASE到s1，则xid=1，和顶层事务一致）
ROLLBACK TO SAVEPOINT s1;
COMMIT;

-- 4 check
\c pubdb
SELECT xmin,* FROM t1 ORDER BY c1;

\c subdb
SELECT * FROM pg_stat_subscription;
SELECT xmin,* FROM t1 ORDER BY c1;

# 发布端：2阶段处理
ReleaseSavepoint
 for loop:
 cur = CurrentTransactionState
 cur->blockState = TBLOCK_SUBRELEASE
 cur = cur->parent

CommitTransactionCommand
 if CurrentTransactionState is TBLOCK_SUBRELEASE
 for loop:
 CommitSubTransaction
 AtSubCommit_childXids
 CurrentTransactionState->parent->childXids[cnt++] = CurrentTransactionState->xid
 PopTransaction
 CurrentTransactionState = s->parent

# 订阅端：
pa_start_subtrans
 DefineSavepoint
 subxactlist = lappend_xid(subxactlist, current_xid)

apply_handle_stream_commit

pa_stream_abort
 for loop:
 curxid = subxactlist
 if curxid == subxid:
 RollbackToSavepoint

实现原理：

PostgreSQL 3-13 逻辑复制原理与性能优化

Mon, 29 Dec 2025 20:38:00 +0800

1 基本概念

1.1 业务场景

场景一：数据共享（异构数据库）
1个公司，有2个部门：商品库存部门、商品成本部门。2个部门有不同技术栈，使用不同数据库产品:postgresql、mysql。2个部门需共享相同的表：商品信息表。
场景二：数据容灾
应用存储数据时，同时将数据存储至postgresql于mysql中，避免某款数据库出现无法恢复的数据损坏问题。
场景三：版本升级
从postgresql 13版本，升级到postgresql 16版本。
场景四：数据迁移（异构数据库）
从postgresql，将数据库迁移到mysql中。

PostgreSQL 3-13 Vastbase 逻辑复制

Thu, 27 Nov 2025 19:07:00 +0800

2 使用

2.1 发布端

配置

# vb
echo "wal_level=logical" >> $GAUSSHOME/data/postgresql.conf
echo "max_replication_slots=4" >> $GAUSSHOME/data/postgresql.conf
echo "max_wal_senders=4" >> $GAUSSHOME/data/postgresql.conf
# echo "max_worker_processes=8" >> $GAUSSHOME/data/postgresql.conf
echo "max_logical_replication_workers=32" >> $GAUSSHOME/data/postgresql.conf

echo "listen_addresses='*'" >> $GAUSSHOME/data/postgresql.conf

sed -i '1i host all all 0.0.0.0/0 md5\n' $GAUSSHOME/data/pg_hba.conf
echo "host replication all 0.0.0.0/0 md5" >> $GAUSSHOME/data/pg_hba.conf
# host all all 0.0.0.0/0 md5

psql -d postgres -c "SELECT name,setting FROM pg_settings WHERE name in
 ('wal_level', 'max_replication_slots', 'max_wal_senders', 'max_worker_processes', 'max_logical_replication_workers')"

创建基表

CREATE DATABASE pubdb;
\c pubdb
CREATE TABLE pt1(c1 INT,c2 TEXT);
CREATE TABLE pt2(c1 INT, c2 TEXT);
INSERT INTO pt1 VALUES (1,'data1-1'), (2,'data1-2');
INSERT INTO pt1 VALUES (1,'data2-1'), (2,'data2-2');

创建发布用户

PostgreSQL 3-13 逻辑复制性能优化

Fri, 21 Nov 2025 15:18:00 +0800

2025-11-21：持续更新中…

1 需求概述

1.1 原始需求

主备部署模式下，滚动升级时，可能存在主节点未升级，备节点已升级的情况。在该条件下，客户要求主节点持续执行事务，并且主节点及时将数据同步至备节点。目前，存在一下问题：

物理复制无法使用：由于主节点、备节点版本不一致，主节点生成的wal，备节点可能无法使用。因此，只能使用逻辑复制方案。
逻辑复制性能较低：主节点作为发布端，解码wal。备节点作为订阅端，接收loggic-wal，并且回放logic-wal，可解决主备版本不一致的问题。但是，目前Vastbase的逻辑复制功能性能较低，无法满足及时同步数据的要求。

本需求将针对上述场景，端到端优化逻辑复制功能，让逻辑复制性能整体提升5倍以上，达到100m/s的要求。

需求来源：https://doc.weixin.qq.com/doc/w3_AYsAjQYkADwCNecwqsBM8ShS9YejB?scode=AHUAfwdSAA8UDeKla8AdwAfAa7AFk&roomid=Person%3A1688855660690652%3A1688855164259723&version=5.0.2.6008&platform=win

1.2 问题分析

逻辑复制分为多个阶段，openGauss和PostgreSQL在部分阶段中做了优化，但未端到端优化。因此，本文将以早期逻辑复制为基础，指出优化设计。

版本一：串行复制

在postgresql 13以及之前版本，逻辑复制的关键设计如下：

发布端：
- 解码日志：wal-sender进程，持续读取wal，串行对wal进行decode，生成logic-wal，并将不同事务的logic-wal，分别存放。
- 发送日志：对wal进行decode时，如果是事务提交产生的wal，则将该事务的所有logic-wal打包，并发送到订阅端。
订阅端：
- 回放日志：apply-worker进程，一次接收同一事务的一批logic-wal，串行回放本批logic-wal后，重新等待下一个事务的logic-wal。

整体方案如下：

以上设计，存在多项性能瓶颈，以常见的tpcc测试为例，可能有400+postgres进程在执行事务，实时产生wal日志。但是，只有1个wal-sender进程在串行解码日志，只有1个apply-workder在串行回放日志。

1.3 方案设计

版本二：发布端并行解码

在openGauss中，针对发布端的解码日志阶段，进行了优化，引入多个decoder线程，并行解码wal生成logic-wal。方案设计如下：

但是，在订阅端，每次对一个事务的一批logica-wal全部回放后，才会接收下一个事务的logic-wal。仅引入并发解码机制，对性能提升较小。发布端和订阅端，均存在负载不均衡的问题，例如，订阅端回放完一个事务的logic-wal之后，需等待下一个事务的logic-wal。

版本三：流氏复制协议

在postgrsql 14版本，针对发布端发送日志阶段，进行了优化，引入流式复制协议，即无需一次发送完一个事务完整的一批logic-wal，而是随时发送logic-wal，即使事务未提交。可解决发布端、订阅端负载不均衡的问题。

但是，在订阅端，tpcc场景，发布端400+postgres进程执行事务，订阅端1个apply-worker进程回放日志，仍是瓶颈。

版本四：订阅端并行回放

在postgrsql 16版本，针对订阅端回放日志阶段，进行了优化，引入多个apply进程，并行回放logic-wal。方案设计如下：

版本五：并行复制

结论：本需求参考性能测试结果，认为需同时结合：并行解码、流式复制、并行回放机制，才能提升逻辑复制端到端性能。
优先级：其中，流式复制、并行回放机制，对性能影响较大，优先级较高。可独立地、优先地实现。
其他工作：同时采用上述3个机制，需合理控制发布端解码速率、订阅端回放速率，在实现负载均衡的同事，避免logic-wal堆积。

2 设计分析

2.1 必要性

根据postgrsql-16的性能测试结果，流式复制和并行回放机制，可达到70Mb/s的复制速度。

一、测试场景

测试机器：
- IP：172.16.103.90
- 硬件：CPU：鲲鹏920-ARM-128核。缓存L1-L2-L3：8M/64M/256M。内存：760G。磁盘：NVME
- 系统：openEuler
tpcc测试场景（为了快速测试，不太标准）
- 数据量：100 warhouse
- 并发：400
- 执行时间：1 min
逻辑复制配置：
- 部署：发布端、订阅端在同一台机器（找不到2台性能机）
- 订阅：创建1个publiction，涵盖所有table

二、测试数据

由于机器、时间等限制，测试未严格控制变量，但是，和准确结果应该有80%以上符合度。

版本	配置	tpmc	发布端-wal写入速度	逻辑复制速度（峰值）	逻辑复制速度（平均值）
postgrsql-14	串行解码、非流式复制、串行回放	约65w	207 Mb/s	-	16 Mb/s
postgresql-16	串行解码、流式复制、串行回放	约65w	212 Mb/s	117 Mb/s	55 Mb/s
postgresql-16	串行解码、流式复制、并行回放(4)	约65w	197 Mb/s	113 Mb/s	71 Mb/s

测试：贾旭辉

详细数据和结论见wiki：https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007526

尝试修改源码，让订阅端只接受日志，不apply，确定发布端解码和发送的瓶颈，但是，测试结果有点奇怪，有空再继续。

2.2 可行性

并行解码：openGauss已引入
流式复制：postgreql-16版本已成熟
并行回放：postgreql-16版本已成熟

2.3 潜在风险

一、数据有一致性

写写冲突

PostgreSQL 3-13 Publication

Thu, 28 Aug 2025 16:18:00 +0800

1 逻辑复制背景

1.1 逻辑复制场景

在使用数据库时，为提高整个系统的可靠性，或实现不同部门数据同步等场景，很多客户的部署模型存在：一主多备、异构数据库等特点，在保证性能的前提下，常见部署模型如下：


+-------------+ sql +---------------------+ wal +--------------------+
| application | --------> | postgresql (master) | -------> | postgresql (slave) |
+-------------+ +---------------------+ +--------------------+
 |
 |
 | decoded-wal +--------------------+
 +---------------------> | mysql, oracle, .. |
 +--------------------+

1.2 逻辑复制功能

1.3 逻辑复制基础

首先，需自行了解一些存储的基本知识，包括事务特性、mvcc机制，表的物理存储格式：filenode、page、tuple等。
此处，以一个例子，介绍什么wal日志的特点。需了解一些

应用执行事务
假设同一时间，有2个事务，事务id分别为10和11。

时间	应用1	应用2
0	CREATE TABLE t1 (c1 INT,c2 INT)	-
1	CREATE TABLE t2 (c1 INT,c2 INT)	-
2	BEGIN (xid=10)	-
3	INSERT INTO t1 VALUES(10, 1)	-
4	-	BEGIN (xid=11)
5	-	INSERT INTO t1 VALUES (11, 1)
6	INSERT INTO t2 VALUES (10, 2)	-
7	COMMIT
8	-	DELETE FROM t1 WHERE c1 = 10
9	-	INSERT INTO t2 VALUES (11, 2)
10	-	COMMIT

内核产生wal日志
所有表的wal日志，按生成wal的顺序，组织在一起。上述示例中，产生的wal如下：（此处仅列举关键信息）

PostgreSQL 3-14 物理复制

Fri, 05 Jun 2026 09:56:00 +0800

1 物理复制基本原理

1.1 使用场景

介绍为什么需要物理复制

1.2 相关原理

介绍什么是wal，wal是用来干嘛的

1.3 实现思路

介绍如何基于wal，实现物理复制，并解决1.1中的问题

2 物理复制使用方式

2.1 使用物理复制

3 物理复制工作流程

3.1 整体架构

包括Postgres生成wal，walwriter存储wal，walsender发送wal，walreceive接收wal，startup重放wal，checkpoint/bgwriter等。

3.2 工作流程

参考2.1，梳理完整的工作流程，从主机执行SQL语句开始，到最终备机达到同样效果

4 物流复制实现源码

参考2.1，介绍每一阶段的关键原理，另外，包括wal日志格式等

你好，我要基本当前目录下的代码，生成一份流复制的skill，所以，接下来的对话，都和这件事有关。

海量 4 需求 scram-sha256

Thu, 03 Apr 2025 17:41:00 +0800

深信服支持pg scram-sha256需求

需求目标

本需求的根本目标时，当vastbase server要求使用sha256算法进行身份认证时，postgresql client能与vastbase server建立连接。
该需求目前仅合入深信服分支

需求分析

身份认证的详细流程有点复杂，此处简要概述为2个阶段：

标识：新建用户时，server计算并存储密码哈希值
鉴别：用户登录时，server向client发送计算密码哈希值的关键信息，client计算并向server发送密码哈希值，server校验其是否符合存储的值

vastbase和postgresql对比，server计算密码哈希值的算法不同，server向client发送关键信息也不同。为解决pg-client能够连接vb-server的问题，需解决问题如下：

vb-server计算并存储与pg-server一致的密码哈希值
vb-server向pg-client发送密码哈希值关键信息时，需要pg-server一致

postgreql的标识与鉴别机制，符合标准RFC-5802，涉及的算法与协议，本文统一称为scram-sha256。vastbase涉及的算法与协议，本文统一称为sha256。

需求实现

密码存储：新建用户时，修改存储用户密码的值

修改前：guc参数password_encrypt_type，取值1时，vb-server存储密码的[sha256, md5]值；取值为2时，存储密码的[sha256]值

SELECT rolpassword FORM pgauthid; -- 示例：长度为209
 rolpassword
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
sha256af99537f242c661a88acea99ac626a2cf8fe196ac5671db6f02ed6818b420cf84e7ada61d66602c6eb5bf4ced40911d3f51865959784ebc3b0d385ca4c08f3398f05e16268fe9acc95a2d662bf5033b15d53abd1f835c1a3f1e96343a5cbf800ecdfecefade

修改后：guc参数password_encrypt_type，取值1时，vb-server存储密码的[sha256, md5, scram-sha256]值；取值为2时，存储密码的[sha256, scram-sha256]值

SELECT rolpassword FORM pgauthid; -- 示例：长度342 (新增长度：133)
 rolpassword
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
sha256af99537f242c661a88acea99ac626a2cf8fe196ac5671db6f02ed6818b420cf84e7ada61d66602c6eb5bf4ced40911d3f51865959784ebc3b0d385ca4c08f3398f05e16268fe9acc95a2d662bf5033b15d53abd1f835c1a3f1e963SCRAM-SHA-256$4096:sp5V1hrLKzLsS4HtQgqTuA==$QO/UVdrXxIypzBEGqEuIWe96A80elghFQs25ZbdPsLg=:J4lPXmXPANtTMOkaHokMjmM19K1Di7fU6WRWuZ5VmS0=

认证协议：用户登录时，修改向客户端发送的密码哈希值关键信息

修改前：

# 身份认证协议
1. client <-> server : tcp connect
2. client --> server : send [消息类型:0, 协议版本:3.51，连接参数:user_name, databse, ...]
3. server --> client : send [消息类型:R, 哈希算法:10, 系统表存储的密码的算法:2, 计算密码哈希关键信息：salt,token,iteration]
4. client <-> server : # 省略3次交互

修改后：

数据库安全 Oracle

Sat, 25 Jan 2025 11:07:00 +0800

https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001006330

3 异常参数

3.1 DES encrypt

封装函数

CREATE OR REPLACE FUNCTION desencrypt(hex_plain VARCHAR2, hex_key VARCHAR2)
RETURN VARCHAR2 IS
 cipher RAW(100);
BEGIN
 dbms_obfuscation_toolkit.desencrypt(hextoraw(hex_plain), hextoraw(hex_key), encrypted_data=>cipher);
 RETURN rawtohex(cipher);
END;
/

函数格式
```
desencrypt(plain, key, cipher);
```
约束：

构造用例

明文长度	密钥长度	输出：密文长度	示例	结果
一、正常用例
8	8	8	desencrypt()	abc
16	8	16	desencrypt()	abc
一、明文长度异常
0	8	16	desencrypt()	明文不是8的倍数
1	8	-	desencrypt()	明文不是8的倍数
7	8	-	desencrypt()	明文不是8的倍数
15	8	-	desencrypt()	明文不是8的倍数
二、密钥长度异常
8	0	8	desencrypt()	密钥长度不是8
8	1	8	desencrypt()	密钥长度不是8
8	15	8	desencrypt()	密钥长度不是8
8	16	8	desencrypt()	密钥长度不是8

3.2 DES decrypt

3.3 3DES encrypt

封装函数

数据库安全 0 整体架构

Wed, 22 Jan 2025 11:34:00 +0800

摘要：介绍常见数据库安全机制的原理：
1.身份认证
2.安全传输
3.安全审计
4.访问控制
5.数据发现
6.数据防篡改
7.加密函数
8.透明加密
9.数据脱敏
10.全密态加密
11.机密计算

1 数据库安全概述

1.1 数据库基本功能

本文讨论数据库安全，为方便理解，将大部分软件架构简化为2个主体：应用端与数据库端。

应用：实现业务逻辑，收集业务数据，将数据发送至数据库，由数据库提供数据存储功能，并且，要求数据库提供数据查询功能
数据库：存储业务数据，向应用提供SQL接口，接收应用发送的SQL语句，并处理SQL语句。同时，解决高并发、高性能、高可靠的问题

大部分场景中，应用与数据库部署于不同主机上，以下是一个应用使用数据库实现数据存储与查询的示例流程：

建立连接：应用与数据库建立网络连接
定义数据：应用向数据库发送以下SQL语句，创建1个表
```
CREATE TABLE t1 (c1 INT, c2 TEXT);
```
存储数据：应用向数据库发送以下SQL语句，向表中存储数据
```
INSERT INTO t1 VALUES (1, 'abc');
```
查询数据：应用向数据库发送以下SQL语句，从表中查询数据
```
SELECT * FROM t1;
```

1.2 数据库基本架构

数据库架构较复杂，此处先将数据库架构简单划分为以下3个部分：

数据库驱动：集成到应用内部，向应用提供编程接口，常见接口有：连接数据库、执行SQL语句等
计算模块：解析SQL语句，并按合理地执行流程处理SQL语句中的请求，调用存储模块接口实现数据存储与读取
存储模块：合理组织数据，调用IO接口，实现磁盘读写操作。向计算模块提供接口

1.3 数据库安全威胁

在应用使用数据库的过程中，攻击者可能对整个系统造成恶意攻击，攻击的最终目标是：

破坏业务数据：窃取、伪造、篡改、损坏等
破坏业务系统：拒绝服务等

攻击者针对多个系统薄弱点进行功能：

数据库网络：协议等
数据库应用：身份认证机制等
数据库主机：操作系统、软件（除数据库外的其他软件）、硬件等

假设应用与数据库部署在不同主机，分为是下图中的主机c和主机z，常见安全威胁的架构图如下：

1.4 数据安全架构

针对各类威胁，数据库提供多种安全机制，保护数据与数据库安全，常见的安全机制如下：

身份认证：阻止非法用户与数据库建立网络连接
安全传输：阻止非法用户窃取、篡改、伪造、..传输数据
安全审计：记录非法/合法用户对数据库的操作
访问控制：缩小非法用户对数据库的访问范围
数据发现：协助合法用户识别敏感数据
数据防篡改：识别非法用户篡改、伪造、..存储数据
加密函数：协助合法用户加密存储数据
透明加密：阻止非法用户窃取、篡改、伪造、..存储数据
数据脱敏：缩小非法用户对数据内容的访问范围
全密态加密：阻止非法用户窃取、篡改、伪造、..传输、计算、存储数据
机密计算：阻止非法用户窃取、篡改、伪造计算数据

按对数据处理的顺序，各安全机制的架构如下图所示：

数据结构与算法 4 图

Tue, 21 Jan 2025 13:55:00 +0800

1 图的介绍

1.1 定义

G = (V, E)

一组节点V
一组边E
节点的度：相邻节点的数量
完备图：所有节点都有n-1个相邻节点，即任意2节点间可达

1.2 分类

根据边分类

无向图
```
n1 ---- n2
| |
| |
n3 ---- n4
```
有向图
```
 --> n2
n1 --> n4
 --> n3
```
带权有向图
```
 3
 ---> n2 6
n1 ---> n4
 ---> n3
 5
```

图的性质分类

同构图：G和H，通过重新标记G的节点产生H。阶相等，顶点度数相等
异构图

1.3 表示

邻接矩阵
如果节点间ni,nj之间有弧，则[ni, nj] = 1

 n1 n2 n3 n4
 +------------+
n1 | 0 1 1 0 |
n2 | 0 0 0 1 |
n3 | 0 0 0 1 |
n4 | 0 0 0 0 |
 +------------+

无向图的斜下半部分是多余的

PostgreSQL 4-1 pgaudit

Fri, 23 May 2025 10:54:00 +0800

1 使用pgaudt

1.1 常见SQL

-- 1 ddl
CREATE USER u1 PASSWORD 'u1.password';
CREATE TABLE t1(c1 INT, c2 TEXT);
CREATE TABLE t2 (c1 INT, c2 TEXT);
CREATE INDEX i1 ON t1(c2);

-- 2 dml
INSERT INTO t1 VALUES (1, 'aaa'), (2, 'bbb'), (3, 'ccc');
INSERT INTO t2 VALUES (1, 'aaa'), (5, 'bbb');
UPDATE t1 SET c2 = 'ddd' WHERE c1 < 3;
DELETE FROM t1 WHERE c1 = 2;

-- 3 select
SELECT * FROM t1;

-- 4 function
SELECT c2 || '_oper' FROM t1;
SELECT concat(c2, '_func') FROM t1;
INSERT INTO t1 VALUES (5, concat('aaa', '_func')), (6, concat('aaa', '_func'));

-- 5 multi
INSERT INTO t1 SELECT * FROM t2;
SELECT * FROM t1 JOIN t2 ON t1.c1 = t2.c1;
CREATE TABLE t3 AS SELECT * FROM t2;
DROP TABLE t1,t2,t3;

1 安装pgaudit

1.1 安装postgresql

# 1 配置环境变量
echo 'export BUILD_ROOT=`pwd`' > pgenv
echo 'export PG_HOME=$BUILD_ROOT/install' >> pgenv
echo 'export PATH="$PG_HOME/bin:$PATH"' >> pgenv
source pgenv

# 2 下载源码
wget https://ftp.postgresql.org/pub/source/v14.18/postgresql-14.18.tar.gz
tar -zxvf postgresql-14.18.tar.gz
cd postgresql-14.18.tar.gz

# 3 编译源码 (不开启debug模式，提高性能)
#./configure --prefix=$PG_HOME --enable-debug=yes
./configure --prefix=$PG_HOME --enable-debug=no --enable-cassert=no
make -sj
make install -sj

# ==========================================
cd $BUILD_ROOT/pg14/contrib/pgaudit
make install USE_PGXS=1 PG_CONFIG=$PG_HOME/bin/pg_config
cd -
# ==========================================

# 4 初始化集群
initdb -D $PG_HOME/data

# 4 配置集群
# echo "port = 54000" >> $PG_HOME/data/postgresql.conf
# echo "max_connections = 1000" >> $PG_HOME/data/postgresql.conf

# ==========================================
echo "logging_collector = on" >> $PG_HOME/data/postgresql.conf
echo "shared_preload_libraries = 'pgaudit'" >> $PG_HOME/data/postgresql.conf
echo "pgaudit.log = 'ALL'" >> $PG_HOME/data/postgresql.conf

echo "pgaudit.log_catalog = true" >> $PG_HOME/data/postgresql.conf
echo "pgaudit.log_client = true" >> $PG_HOME/data/postgresql.conf
echo "pgaudit.log_parameter = true" >> $PG_HOME/data/postgresql.conf
echo "pgaudit.log_relation = true" >> $PG_HOME/data/postgresql.conf
echo "pgaudit.log_rows = true" >> $PG_HOME/data/postgresql.conf
echo "pgaudit.log_statement = true" >> $PG_HOME/data/postgresql.conf
# ==========================================

# 5 启动集群
pg_ctl start -D $PG_HOME/data

# ==========================================
DROP EXTENSION pgaudit;
CREATE EXTENSION pgaudit;
CREATE UNLOGGED TABLE adt(c1 TEXT);

CREATE TABLE t1 (c1 INT);
INSERT INTO t1 VALUES (1);

\! ls $PG_HOME/data/log
\! tail $PG_HOME/data/log/
# ==========================================

1.2 tpcc优化

echo "
shared_buffers = 200GB
work_mem = 1GB
maintenance_work_mem = 4GB
effective_cache_size = 500GB
wal_buffers = 1GB
checkpoint_timeout = 55min
" >> $PG_HOME/data/postgresql.conf

show shared_buffers;
show work_mem;
show maintenance_work_mem;
show effective_cache_size;
show wal_buffers;
show checkpoint_timeout;

1.3 安装pgaudit

# 1 下载源码
wget https://codeload.github.com/pgaudit/pgaudit/tar.gz/refs/tags/1.6.2 -O pgaudit-1.6.2.tar.gz
tar -zxvf pgaudit-1.6.2.tar.gz

# 2 编译
cd pgaudit-1.6.2
make install USE_PGXS=1 PG_CONFIG=$PG_HOME/bin/pg_config

# 3 验证编译成功
ll $PG_HOME/share/extension
cat $PG_HOME/data/postgresql.conf | grep shared_preload_libraries

# 4 开启日志功能
echo "logging_collector = on" >> $PG_HOME/data/postgresql.conf
echo "log_statement = all" >> $PG_HOME/data/postgresql.conf

# 5 开启 pgaudit
echo "shared_preload_libraries = 'pgaudit'" >> $PG_HOME/data/postgresql.conf
echo " pgaudit.log = 'ALL'" >> $PG_HOME/data/postgresql.conf

-- 1 安装pgaudit
CREATE EXTENSION pgaudit;

-- 2 查看配置参数
SHOW pgaudit.log;
 -- ALL
 -- READ: SELECT
 -- WRITE: INSERT, UPDATE, DELETE
 -- ROLE
 -- DDL
 -- FUNCTION
 -- MISC
 -- MISC_SET
SHOW pgaudit.role;
SHOW pgaudit.log_level;

-- 查看审计文件
SHOW log_directory;
SHOW log_filename;

审计策略：客户

优先3.0

数据库安全 1 身份认证

Fri, 24 Jan 2025 18:46:00 +0800

摘要：从5个方面，介绍PostgreSQL身份认证特性：背景、原理、使用、设计、实现

1 身份认证概述

1.1 非法访问风险

数据库进程
数据库运行时，本质是一个服务器进程，在特定的主机上，监听特定端口。应用如果知道IP和端口，都可与数据库进程建立TCP连接，并进行数据交互，包括发送SQL语句、接收查询结果等。
数据泄露风险
为避免非法用户访问数据库，构造特殊数据，造成数据损坏、数据泄露等问题，数据库接收应用建立TCP的请求，并成功建立TCP连接后，需先确认应用的身份是否合法，再接收应用的其他数据，比如接收SQL语句等。

1.2 身份认证机制

在信息系统中，身份认证是一种常见的机制，身份认证的概念较成熟，本文不详细介绍相关概念。身份认证分为标识与鉴别两个部分：

标识：用户向系统声明自己的身份，系统标识用户
鉴别：系统验证用户提供的信息，确认用户是否是已标识的用户

按照认证因素，可将身份认证划分为3类：

知识因素：用户知道某些秘密，比如口令、密码等
拥有因素：用户拥有某些实物，比如钥匙、证书、令牌等
生物因素：用户拥有某些特征，比如指纹、面部、虹膜、签名等

1.3 PostgrSQL的身份认证

PostgreSQL的认证方式有很多种，包括：密码认证、Ident认证、Peer认证、证书认证、LDAP认证等。本文仅介绍最常见的方案。

在大部分场景中，PostgreSQL采用以下2层认证机制：

主机认证：
- 标识：在PostgreSQL的配置文件中，配置IP白名单
- 鉴别：PostgreSQL与应用建立连接后，检查应用的IP是否在白名单内，判断应用是否合法
口令认证：
- 标识：PostgreSQL已存在的用户，创建新用户，为其设置用户信息，以及口令
  - 备注：第一次安装PostgreSQL时，PostgreSQL要求用户创建初始用户
- 鉴别：在主机认证后，PostgreSQL先要求应用提供用户信息，再要求应用提供对应的口令，判断应用是否合法

2 身份认证的使用流程

2.1 基本流程

PostgreSQL中，从用户的角度观察，使用身份认证的流程可简单理解为：

用户：已存在的用户使用CRATE USER {username} .. PASSWORD {password} ..语法，创建新用户并设置口令
数据库：数据库先对口令进行哈希，再存储口令的哈希值，目前的版本中，默认哈希算法为sha256算法，用户可通过GUC参数配置哈希算法类型
用户：用户与数据建立连接，将{username}与{password}的哈希值发送给数据库，数据库比较用户发送的哈希值与系统表中的哈希值，判断{password}是否合法

具体实现中，第3步的验证过程较为复杂，RFC5 802协议提供了一套安全的交互流程。后文介绍内部实现的详细流程。

3 身份认证的实现

3.1 基于IP的身份认证

标识：访问者的IP
鉴别：数据库遍历IP白名单，判断访问者IP是否在白名单中，如果在，则认为访问者合法，允许与数据建立TCP连接。

PostmasterMain
 ServerLoop
 ConnCreate
 StreamConnection
 BackendStartup
 BackendRun
 PostgresMain
 InitPostgres
 PerformAuthentication
 ClientAuthentication
 hba_getauthmethod /* 从hba文件中，获取指定ip的认证方式 */
 check_hba
 check_hostname
 check_ip
 /* 如果指定ip未获取到认证方式，则返回空 */
 switch hba->auth_method: /* 根据ip采用不同的认证方式 */
 case uaReject:
 case uaImplicitReject:
 case uaGSS:
 case uaSSPI:
 case uaPeer:
 ...
 case uaMD5:
 case uaPassword:
 case uaCert:
 case uaTrust:
 ...

3.2 基于证书的身份认证

创建主体的语法示例如下：

数据库安全 3 安全审计

Wed, 22 Jan 2025 14:22:00 +0800

摘要：从5个方面，介绍openGauss审计特性：背景、原理、使用、设计、实现

1 审计的背景

1.1 审计的原理

在使用数据库存取数据的大部分场景中，数据库具有以下特点：

对象多：一个数据库集群中有多个database对象，1个database对象中有多个schema对象，1个schema对象中有多个table、index等对象
用户多：一个数据库中，有多个用户，每个用户可访问的数据库对象不同
应用多：多个应用将数据存储在同一数据库集群中，并同时访问数据库集群
操作多：数据库提供丰富的功能，包括DDL、DML、DCL、运维等
运行久：一个数据库集群，可能会保持数十年运行

审计的主要目的，使记录数据运行过程中发生了哪些事件。审计的3要素是：

主体：一般指数据库用户
客体：一般指数据库对象，包括：集群、用户、连接、数据对象（database、schema、table、index、function等）
操作：主体对客体的操作，比如某个用户访问了某个表

1.2 审计的目的

审计具有以下重要意义：

攻击检测：通过检查审计日志，可判断是否发生网络安全攻击事件
例行维护：通过检查审计日志，可跟踪对某个对象的访问信息
故障检测：当数据库出现故障是，协助快速定位问题
合法合规：《网络安全法》等法律法规与表中中，要求应用具备审计功能
…

1.3 审计的功能

审计功能包含以下3个部分：

设置审计范围：通过数据库配置参数，或者数据库语法，定义哪些对象需要被审计
设置审计存储：通过数据库配置参数，定义审计日志如何存储
生成审计日志：数据库运行过程中，访问某个对象时，记录访问信息
管理审计日志：查询，删除，归档审计日志

1.4 oracle审计

oracle审计的发展：
- oracle 8i及更早：支持传统审计
- oracle 12c：新增支持统一审计
- oracle 23ai：不支持传统审计，仅支持统一审计

oracle统一审计的使用：

-- 1 创建审计策略
CREATE AUDIT POLICY ap1
 PRIVILEGES CREATE TABLE, ALTER USER -- privilege 子句，记录所有使用CreateTable, AlterUser权限的操作
 ACTIONS SELECT,INSERT,UPDATE ON t1 -- aciton 子句，记录所有对表t1执行SELECT,INSERT,UPDATE的操作
 ROLES r1; -- role 子句，记录所有使用r1角色的操作

-- 2 启用审计策略
AUDIT POLICY ap1;

-- 3 查看审计日志
SELECT * FROM UNIFIED_AUDIT_TRAIL;
-- DBA_COMMON_AUDIT_TRAIL, DBA_AUDIT_SESSION, DBA_AUDIT_OBJECT, DBA_FGA_AUDIT_TRAIL
SELECT * FROM DBA_AUDIT_TRAIL;
os_username | username | userhost | terminal | timestamp | owner | obj_name | action | action_name |
------------+----------+----------+----------+-----------+-------+----------+--------+-------------+

| new_owner | new_name | obj_privilege | sys_privilege | admin_option | grantee | audit_option | ses_actions |
+----------+----------+---------------+---------------+--------------+---------+--------------+-------------+

logoff_time | logoff_lread | logoff_pwrite | logoff_dlock | comment_text | sessionid | entryid | statementid | returncode |
+-----------+--------------+---------------+--------------+--------------+-----------+---------+-------------+------------+

| priv_used | client_id | econtext_id | session_cpu | extended_timestamp | proxy_sessionid | global_uid | instance_number |
+-----------+-----------+-------------+-------------+--------------------+-----------------+------------+-----------------+

os_process | transactionid | scn | sql_bind | sql_text | obj_edition_name | dbid | rls_info | current_user |
+----------+---------------+-----+----------+----------+------------------+------+----------+--------------+

其中，可设置的权限、操作等范围如下：

数据库安全 4 访问控制

Wed, 05 Feb 2025 16:57:00 +0800

1 访问控制的背景

在使用数据库存取数据的大部分场景中，数据库具有以下特点：

对象多：一个数据库集群中有多个database对象，1个database对象中有多个schema对象，1个schema对象中有多个table、index等对象
用户多：一个数据库中，有多个用户，每个用户可访问的数据库对象不同

在该场景中，通过访问控制机制，可限制某个对象访问数据库对象的范围

2 访问控制的原理

访问控制的模型是：主体、客体、操作。本文不解释基本概念。

主体
USER

角色：

SYSADMIN 系统管理员
CREATEROLE 安全管理员
AUDITADMIN 审计管理员
MONADMIN 监控管理员
OPRADMIN 运维管理员
POLADMIN 安全策略管理员

客体
DATABASE
SCHEMA
TABLESPACE
TABLE
COLUMN
FUNCTION
PROCEDURE
SEQUENCE
FOREIGN SERVER
LANGUAGE

操作	客体
CREATE	DATABASE, SCHEMA, TABLESPACE
ALTER	DATABASE, SCHEMA, TABLESPACE, TABLE, FUNCTION, PRODUCE, FOREIGN SERVER, DIRECOTRY, PACKAGE
DROP	DATABASE, SCHEMA, TABLESPACE, TABLE, FUNCTION, PRODUCE, FOREIGN SERVER, DIRECOTRY, PACKAGE
TRUNCATE	TABLE
VACUUM	TABLE
INDEX	TABLE
TRIGGER	TABLE
SELECT	TABLE, COLUMN, SEQUENCE
INSERT	TABLE, COLUMN
UPDATE	TTABLE, COLUMN, SEQUENCE
DELETE	TABLE
TEMPORARY	DATABASE
EXECUTE	FUNCTION, PROCEDURE, PACKAGE

语法：

数据库安全 5 全密态

Wed, 24 Jun 2026 14:47:00 +0800

0 基础调研
1. 一、运算符
2. 二、数据类型
1 架构设计
1. 工作计划
2 驱动加密 - 实现
3 机密计算 - 实现
4 测试用例
附录：专利
附录：AI
1. 代码要求：
附录：参考文献

0 基础调研

一、运算符

运算符
以int4为例：select proname from pg_catalog.pg_proc where proname like '%int4%' order by proname;
- 一、比较运算符函数

数据库安全 9 透明加密

Tue, 21 Jan 2025 13:55:00 +0800

1 透明加密背景

在另一篇博客中，已经讨论了几个话题：

数据泄露风险
加密方案对比
透明加密基本原理

因此，本篇博客直接进入主题，介绍openGauss透明加密特性。

2 透明加密使用

2.1 开启透明加密

2.2 定义加密表

CREATE TABLE t1 (c1 INT, c2 TEXT) WITH (enable_tde=on);

2.3 验证数据加密

3 透明加密设计

4 透明加密原理

1 概述

1.1 模块

heapam -> buffer -> smgr -> page

1 概述

1.1 功能

用户创建表时，通过SQL语句指定表是否加密
数据库将数据页写入磁盘时，判断如果数据页属于加密表，对数据先加密在存储
数据库从磁盘读取数据页时，判断如果数据页已被加密，读取后马上解密

1.2 适配点

初始化page
存储page
读取page
生成xlog记录：考虑初始化pagee
重放xlog记录：考虑初始化page

1.3 kun tde

2 调用关系

2.1 初始化数据页

PageInit

PageInit(Page page, Size pageSize, Size specialSize)
 heap_xlog_insert()
 heap_xlog_multi_insert()
 heap_xlog_update()
 heap_xlog_visible()
 raw_heap_insert()
 PageGetTempPageCopySpecial()
 fill_seq_with_data()
 seq_redo()
 brin_page_init()
 lazy_scan_heap()
 GinInitPage()
 GISTInitBuffer()
 _hash_pageinit()
 _bt_pageinit()
 SpGistInitPage()
 vm_readbuf()
 vm_extend()
 XLogRecordPageWithFreeSpace()
 fsm_readbuf()
 fsm_extend()

image

2.2 写入数据页

smgrextend

调用栈：

海量 5 用例 G100审计重构

Thu, 16 Oct 2025 18:05:00 +0800

1 正常场景

CREATE USER u1 PASSWORD 'u1.password';
set role u1 password 'u1.password';

-- ddl
DROP TABLE t1;
DROP FUNCTION f1;

CREATE TABLE t1(c1 INT, c2 TEXT);
-- dml
INSERT INTO t1 VALUES (1, 'aaa'), (2, 'bbb');
UPDATE t1 SET c2 = 'aba' WHERE c1 = 1;
SELECT * FROM t1;
DELETE FROM t1 WHERE c1 = 2;
-- func
CREATE FUNCTION f1() RETURNS INT AS $$ SELECT count(*)::INT FROM t1 $$ LANGUAGE sql;
SELECT f1();
-- trans
BEGIN;
SELECT * FROM t1;
COMMIT;

DROP TABLE t1;
DROP FUNCTION f1;

reset role;
select * from pg_audit_log;

2 异常场景

CREATE USER u1 PASSWORD 'u1.password';
CREATE TABLE st1(c1 INT, c2 TEXT);

set role u1 password 'u1.password';
-- doest't exist
SELECT * FROM nt1;
-- permission deny
SELECT * FROM st1;

reset role;
select * from pg_audit_log;

海量 5 设计 G100审计

Mon, 01 Sep 2025 18:00:00 +0800

G100审计功能重构

1 功能简述

在需求文档中，已详细介绍需求背景，此处不在重复介绍。
G100 309之前版本，审计特性存在较多问题，因此，在本版本，将重新设计与实现审计特性，解决功能、性能、易用性、可维护性、可扩展性等问题，使审计特性达到大规模商用的标准。

2 实现方案

一、审计架构

审计特性，核心子功能如下：

配置审计：通过GUC参数，配置审计参数：日志目录、目录大小、日志文件淘汰策略等
设置范围：通过SQL语法，设置审计策略，控制哪些事件需审计。在策略中，可按用户、操作、对象、操作结果等过滤事件
收集事件：在代码关键节点，收集事件
过滤事件：根据审计策略，过滤无需审计的事件
生成日志：提取事件关键信息，生成日志
传输日志：工作线程，通过共享内存，传输日志给审计线程
存储日志：审计线程，组织日志，并将其存储至文件中。文件存放在单独的日志目录
查询日志：通过内置FUNCTION，在线查询日志，通过TOOL，离线查询日志

其中，设置范围、过滤事件子功能相对独立，可单独设计与实现，所以，拆分到另一个的设计文档中。

审计特性整体架构图如下：

二、工作流程

收集事件的主体、操作、客体等信息时，因为需收集操作结果，即操作成功或失败，所以，很多场景中，收集事件需分为2个阶段：

执行操作前：收集事件基本信息，包括操作类型等
执行操作后：收集事件的操作结果。对于出现ERROR的场景，则在异常处理函数中收集操作结果。

在所有事件中，DML语句的事件稍复杂一点，此处主要以该类语句为例，梳理整体执行流程：

三、详细流程

阶段1 配置审计（进程启动）

首先，用户通过GUC参数，配置审计文件管理等功能。然后，在系统启动阶段，审计模块将根据配置，初始化的各类关键资源，包括：

日志文件：日志存储目录，初始日志文件等
审计内存：日志缓存区，内存上下文等
审计线程：信号处理函数等
事件收集节点：hook函数注册等

详细启动过程如下：

main # 1. 启动vastbase进程
 knl_instance_init
 MemoryContextInit
 PostmasterMain # 2. 启动postmaster线程
 SelectConfigFiles # 3. 加载GUC参数
 checkDataDir
 'audit_dir_init' # 4. 创建审计日志文件目录
 'audit_hook_init' # 5. 注册审计回调函数：身份认证等
 load_hba
 reset_shared
 CreateSharedMemoryAndSemaphores # （日志缓冲区不是共享内存，后文阶段6详细介绍）
 GlobalSysDBCache::Init
 CreateLocalSysDBCache
 InitRoleIdHashTable
 'audit_comm_init' # 6. 初始化审计内存上下文、日志缓存区，创建审计日志文件
 'initialize_util_thread(AUDIT_WRITER)' # 7. 启动audit-writer 线程，持续读取日志缓冲区，等待接收与存储日志
 initialize_thread
 ..
 # ===== audit-writer 线程 ==============
 GaussDbThreadMain
 InitShmemAccess
 InitAuxiliaryProcess
 CreateSharedMemoryAndSemaphores
 GaussDBAuxiliaryThreadMain
 BaseInit
 'adt_writer_main'
 # ===== audit-writer 线程 ==============
 ServerLoop
 for (;;)
 comm_select
 ConnCreate # 9. 接收客户端连接
 BackendStartup
 initialize_util_thread(WORKER)
 initialize_thread
 ..
 # ===== postgres 线程 ==============
 GaussDbThreadMain
 knl_thread_init
 InitializeGUCOptions
 CreateLocalSysDBCache
 'audit_hook_init' # 10. 注册事件收集回调函数：计划执行、函数执行等回调点
 BackendInitialize
 BackendRun
 PostgresMain
 # ===== postgres 线程 ==============
 'initialize_util_thread(AUDIT_WRITER)' # 11. 检查audit-writer 线程状态与自动重启

阶段2 设置范围

向用户提供SQL接口，用于创建审计策略。（见另一个设计文档）

海量 5 需求 G100审计

Wed, 27 Aug 2025 15:13:00 +0800

1 简介

1.1 目的

审计特性：

功能：收集数据库内的关键事件，例如启动集群、创建对象、查询数据等，根据事件生成与存储审计日志，向用户提供审计日志查询接口。
必要：从客户角度，使用审计特性，主要目的包括：合法合规、安全监控、事故调查等。从内核角度，为满足信创要求，数据库需达到CC标准，在CC标准中，对审计功能提出多项要求。
问题：G100审计特性存在多处设计缺陷，导致功能问题多、性能低、易用性差、可维护性差、可扩展性差等。到目前为止，其中累计识别50+缺陷，仍具有30+未识别缺陷。
历史：openGauss早期版本，华为以色列团队开发审计特性，交付标准为基本功能可用，与商用标准差距大。G100早期版本，由openGauss引入审计特性。在之后版本，G100进行多轮迭代。

本需求的目标是重构审计特性，解决功能、性能、易用性、可维护性、可扩展性等问题，使审计特性达到大规模商用的标准。

1.2 适用范围

G100 3.0.8 psu5以及之后版本

1.3 术语定义、首字母缩写词和缩略语

暂无

1.3 参考资料

原始需求：https://www.tapd.cn/tapd_fe/60475194/story/detail/1160475194001083526
国标查询下载网站： https://openstd.samr.gov.cn/bzgk/gb/index
CC标准
- 《GB/T 20009-2019 信息安全技术数据库管理系统安全评估准则》
- 《GB/T 20273-2019 信息安全技术数据库管理系统安全技术要求》
信创标准
- 《SJ/T 11939-2024 安全可靠集中式事务型数据库技术要求》
- 《T/AIA 016—2023信创产品测评通用要求》
等保标准
- 《GB/T 25070-2019》信息安全技术网络安全等级保护安全设计技术要求》
数据库政府采购标准：https://jx.mof.gov.cn/xxgk/zhengcefagui/202401/t20240105_3925117.htm
标准原文：微盘：https://drive.weixin.qq.com/s?k=AHUAfwdSAA87Z01xB
G100审计特性：https://docs.vastdata.com.cn/zh_CN/VastbaseG100/V3.0.8/1/2f4fb0e4adcc49f8b19dd4710f2a6549
G100审计历史客户需求：https://www.tapd.cn/tapd_fe/60475194/story/list?sort_name=created&order=&useScene=storyList&groupType=&conf_id=1160475194001046742&queryToken=fe85cdfc29d23bba423905c15d72d127&page=1
Oracle审计特性：https://docs.oracle.com/en/database/oracle/oracle-database/23/dbseg/part_6.html
开源组件pgaudit：https://www.modb.pro/db/105894
需求分析与整理文档：语雀：https://www.yuque.com/u57264336/oav5h4/tkhcgdilcbpuqm09

2 G100审计功能重构

2.1 功能简述

一、需求背景：审计特性

审计目的：记录数据库内的各种事件，事件包括：
- 启动、恢复、切换、停止集群
- 登录、注销账号
- 创建、修改、删除数据库对象，包括：DATABASE、SCHEMA、TABLE等
- 插入、更新、删除、查询关系表
- …
描述事件：每个事件中，有3个关键要素：<主体><操作><客体>
- 主体：一般是数据库用户
- 客体：集群、账号、DATABASE、SCHEMA、TABLE、FUNCTION等
- 操作：不同的客体，涉及的操作不一样。比如，对于TABLE，操作有：CREATE, INSERT, SELECT等。
审计日志：针对每个事件，收集与主体、操作、客体有关的信息，封装为1条审计日志。通常，1条审计日志中，包括的信息如下：
- 主体相关：用户名、客户端IP、会话ID等
- 操作相关：操作的类型、操作的时间、触发操作的SQL语句等
- 客体相关：客体类型、客体名称、客体属于哪个database、客体属于哪个schema
审计特性：为实现审计功能，在数据库内核中，需实现以下功能：
- 配置范围：对用户提供接口，配置需审计的事件范围
- 收集事件：在内核关键代码节点，发现事件，例如：登录用户、创建对象、查询数据等，收集主体、操作、客体相关信息
- 生成日志：按统一格式组织事件信息，生成审计日志
- 存储日志：将审计日志存储至磁盘
- 查询日志：对用户提供接口，查询日志

二、需求背景：G100审计特性（旧版本）

G100早期版本，引入openGauss审计特性，但是，该特性存在较多问题，包括：

海量 5 方案 G100审计重构

Wed, 23 Apr 2025 18:00:00 +0800

1 审计特性介绍
2 使用审计特性
3 审计特性变更点
3 审计特性详细设计
4 审计后续重构计划

摘要

介绍审计特性，分析性能问题，提出优化方案，评审优化方案，规划其他计划

1 审计特性介绍

1.1 核心功能

审计特性：记录数据库内的各种事件，事件包括：

数据库安全统一管理

Sat, 25 Jan 2025 21:10:00 +0800

2 使用方法

2.1 设置安全策略

表级

CREATE TABLE t1 (c1 INT, c2 TEXT);

-- 1 身份认证

-- 2 安全传输

-- 3 安全审计
CREATE SECURITY POLICY ad1 ON t1 USE (type='security audit', scope='create, insert, update');

-- 4 访问控制
CREATE SECURITY POLICY ac1 ON t1 USE (type='access control', group='user1, user2, user3');

-- 5 数据发现

-- 6 数据防篡改
CREATE SECURITY POLICY lga ON t1 USE (type='ledger');

-- 7 加密函数

-- 8 透明加密
CREATE SECURITY POLICY se1 ON t1 USE (type='storage encrypt', key='key1');

-- 9 数据脱敏
CREATE SECURITY POLICY ms1 ON t1 USE (type='mask', type='money');

-- 10 全密态加密
CREATE SECURITY POLICY ce1 ON t1 USE (type='client encrypt', key='key1');

-- 11 机密计算

列级

PostgreSQL 5-1 libpq

Tue, 30 Jun 2026 14:43:00 +0800

简介

postgresql 简单架构

application driver(jdbc/libpq/..) server
+-----------------------------------------------+-----------------------------------------+---------
| PQconnect(host, port, user, name)
 | do something ..
| PQexec("create table t1(c1 int, c2 text)") |
 | PQexecStart()
 | PQsendQuery()
 | pqPutMsgStart('Q')
 | pqPutnchar("$sql")
 | pqPutMsgEnd()
 | pqFlush()
 | | SocketBackend()
 | pq_parse_input()
 | 'Q': exec_simple_query()
| PQexec("insert into t1 values(1,'a'),(2,'b')")|
| PQexec("select * from t1")
 | ..
 | ..
 | exec_simple_query()
 |

libpq的功能
- 连接管理
- 协议编码
- 数据收发

连接管理

application driver(jdbc/libpq/..) server
+-------------------------------------------+-----------------------------------------+---------
| connect(host, port, user, name)

协议编码

消息通用格式

海量 6 设计 greenplum

Thu, 15 May 2025 16:36:00 +0800

1 需求分析

透明加密
- 主密钥
动态脱敏
- 和统一审计共用resource lable模块
全密态
- 密态等值
- 密态非等值
  - 范围查询：OPE保序加密
  - 模糊查询
  - 内置函数
  - 排序
  - ..
防篡改
- 分布式：有点麻烦，区块链记录在每个节点上
- 哈希函数：md5

1.1 透明加密

模块分析
- 密钥管理
  - 设置主密钥
- 定义加密属性
  - 表：普通表、临时表、分区表、toast表
  - 索引
  - xlog
- 加密数据
  - 加密算法：aes-256-ctr, sm4-ctr
  - 备机加密

-- 创建主密钥

-- 设置表加密
CREATE TABLE t1 (c1 INT, c2 TEXT) WITH (enable_tde=on);

-- 验证数据加密存储
INSERT INTO t1 VALUES (1, 'bbbcccddd');

1.2 动态脱敏

-- 开启脱敏功能
gs_guc reload -D $GAUSSHOME/data -c "enable_security_policy=on"

-- 创建表
CREATE TABLE t1 (c1 TEXT, c2 TEXT);
INSERT INTO t1 VALUES ('bbccdd', 'bbccdd');

-- 创建用户
CREATE USER u1 PASSWORD 'u1.password';
CREATE USER u2 PASSWORD 'u2.password';
GRANT SELECT ON t1 TO u1;
GRANT SELECT ON t1 TO u2;

-- 创建资源标签（只对u1脱敏）
CREATE RESOURCE LABEL l1 ADD COLUMN(t1.c1);
CREATE MASKING POLICY m1 randommasking ON LABEL(l1) FILTER ON ROLES(u1);

-- 验证脱敏：只有u1脱敏
SET ROLE u1 PASSWORD 'u1.password';
SELECT * FROM t1;
RESET ROLE;

SET ROLE u2 PASSWORD 'u2.password';
SELECT * FROM t1;
RESET ROLE;

-- 清理环境
DROP MASKING POLICY m1;
DROP RESOURCE LABEL l1;
DROP TABLE t1;
DROP USER u1,u2;

1.3 全密态

模块分析
- 客户端
  - 语法解析
  - 语义分析
  - 加密
- 服务端
  - ..

1.4 防篡改

hash算法：md5

2 greenplum

yum install zstd libzstd-devel krb5-devel krb5-libs cyrus-sasl-gssapi libevent-devel libyaml-devel libxml2 libxml2-devel curl libcurl-devel
yum install apr apr-devel apr-util apr-util-devel
yum install expat-devel openldap-devel bzip2 bzip2-devel xerces-c xerces-c-devel python36-devel

ln -s /usr/include/python2.7/Python.h /usr/include/Python.h

# 报错就降级
yum downgrade expat-2.1.0-12.el7

mkdir install
cd install
# echo ''使用单引号可防止变量$PATH等展开
echo '
export GPHOME=`pwd`/install

export BINARYLIBS=`pwd`/../third
export GCC_PATH=$BINARYLIBS/buildtools/gcc10.3
export CC=$GCC_PATH/gcc/bin/gcc
export CXX=$GCC_PATH/gcc/bin/g++
export LD_LIBRARY_PATH=$GCC_PATH/gcc/lib64:$GCC_PATH/isl/lib:$GCC_PATH/mpc/lib/:$GCC_PATH/mpfr/lib/:$GCC_PATH/gmp/lib/:$LD_LIBRARY_PATH
export PATH=$GCC_PATH/gcc/bin:$PATH
' > genv
# 建议把环境变量再在~/.bashrc中写一份，因为初始化集群时，需要ssh登录，以初始化segment节点

./configure --with-python --with-libxml --with-gssapi --without-zlib --with-gpcc --prefix=$GPHOME
make -sj 16
make install -sj 16

echo "
ARRAY_NAME="Greenplum Cluster"
SEG_PREFIX=gpseg #segment数据库前缀名
PORT_BASE=40000 #segment数据库起始端口号
declare -a DATA_DIRECTORY=(//home/shenkun/gp/install/segdata)
#segments数据目录，有几个DATA_DIRECTORY, 每个节点上便会启动几个segment，本例为2个segment
MASTER_HOSTNAME=master #master主机名
MASTER_DIRECTORY=/home/shenkun/gp/install/master #master数据目录
MASTER_PORT=5000 #master端口号，也是对外业务端口号
TRUSTED_SHELL=ssh
CHECK_POINT_SEGMENTS=8
ENCODING=UNICODE
DATABASE_NAME=gpdb
MACHINE_LIST_FILE=/home/shenkun/gp/install/hostfile #集群配置文件，hostfile对应7中创建的文件名
" > gpcfg

echo "master" > hostfile

gpinitsystem -c gpcfg -a

psql -p 5000 -d gpdb

PGOPTIONS='-c gp_session_role=utility' psql -p 40000 -d gpdb

# @ master
exec_simple_query
 pg_parse_query
 pg_analyze_and_rewrite
 pg_plan_queries
 pg_plan_querie
 planner
 standard_planner
 subquery_planner
 cdbllize_adjust_top_path
 create_plan
 cdbpathtoplan_create_flow
 makeFlow
 cdbllize_decorate_subplans_with_motions
 PortalStart
 ExecutorStart
 standard_ExecutorStart
 CdbDispatchPlan
 # @ segment
 exec_mpp_query
 deserializeNode
 PortalStart
 PortalRun
 PortalDrop
 PortalRun
 PortalRunMulti
 ProcessQuery
 ExecutorStart
 ExecutorRun
 standard_ExecutorRun
 ExecutePlan
 ExecutorFinish
 ExecutorEnd
 PortalDrop

海量 8 需求海康身份认证

Mon, 30 Jun 2025 18:32:00 +0800

本需求包含6个小需求：

身份认证：创建用户：CREATE/SET USER .. PASSWORD ..，密码可以只设置2类字符
身份认证：创建用户：CREATE/SET [角色] USER ..，角色支持指定SUPERUSER和NOSUPERUSER
身份认证：查看用户：SELECT .. FROM pg_user，普通用户可查询pg_user视图（仅pg兼容性）
身份认证：登录用户：SET ROLE new_user [PASSWORD ..]，new_user是会话用户时，可以不指定PASSWORD
访问控制：Database权限：普通用户可访问template1数据库（仅pg兼容性）
访问控制：Schema权限：普通用户可在public下执行CREATE操作（仅pg兼容性）

描述

身份认证：创建用户
变更：用户密码可以只包含2类字符

-- password_polcy取值不同，密码需包含的字符种类数不同，为1时需3类，需2时需4类，为3时需2类
ALTER SYSTEM SET password_policy OT 3; -- 修改取值范围[0,2]为[0,3]
CREATE USER u1 PASSWORD 'password1'; -- 此时，密码可以只含2类字符
ALTER USER old_user PASSWORd 'password1';

身份认证：创建用户
变更：可以指定SUPERUSER角色

CREATE USER u1 SUPERUSER PASSWORD ..; -- 支持设置 SUPERUSER 角色
ALTER USER u1 NOSUPERUSER ..; -- 支持取消 SUPERUSER 角色
ALTER USER old_user SUPERUSER ..;

身份认证：查看用户
变更：普通用户可查询pg_user视图（仅pg兼容性）

WAL 加密模块设计

Mon, 07 Sep 2026 15:30:00 +0800

假设集群里已经存在表级透明加密模块，在此基础上设计一个高性能、高易用性的 WAL 加密模块。

WAL 加密的难点几乎不在"加密"本身，而在两件事：同一个 8KB 页会被反复重写，以及恢复路径要在拿不到 catalog 的时候就能解密。下面按设计决策的顺序展开。

1 威胁模型

先划清边界，因为它直接决定后面几个取舍。

要防的：磁盘 / 备份 / 归档介质被拖走；DBA 之外的运维人员直接读 pg_wal/；WAL 归档到对象存储。
不防的：有 root 权限的在线攻击者（内存里必然有明文）、旁路攻击。

1.1 为什么不用 dm-crypt 了事

如果只是防"介质丢失"，块设备加密（LUKS/dm-crypt）性价比高得多。在数据库内核里做 WAL 加密，真正的理由只有三个：

密钥要由数据库自己管，不能落在 OS 层（密评 / 国测要求）；
归档件要天然带密；
和已有的表级 TDE 共用一套密钥体系。

设计要始终对齐这三个理由，否则很容易做成一个又慢、又没多大意义的模块。

1.2 FPI 是必须堵的洞

既然表级 TDE 已经存在，那么 FPI（full page image）就是个必堵的泄漏点。

如果 TDE 是在 smgr 层做的（缓冲区里是明文、写盘时加密），那么 WAL 里的 FPI 记录的是明文页 —— 加密表的数据会原封不动地漏进 WAL。

只要集群里存在任何一张加密表，WAL 加密就必须强制开启，不能是两个独立开关。

实现上做成一个集群级的 data_encryption = on，或者至少让 CREATE ENCRYPTION POLICY 在 WAL 加密未开启时直接报错。这是易用性设计里最重要的一条：不要把一个"配错了就静默泄密"的组合留给用户。

Vastbase 数据库研发过程安全分析报告

Fri, 14 Aug 2026 17:53:00 +0800

c++

Thu, 13 Aug 2026 10:54:00 +0800

1 容器

1.1 基本概念

c++ stl

对象
指针
引用
迭代器
容器接口

1.1 接口

// 1.1 vector —— 动态数组
vector<int> v = {1, 2, 3};
v.push_back(4); // 末尾添加
v.pop_back(); // 删除末尾
v.size(); // 元素个数
v.empty(); // 是否为空
v[0]; // 随机访问（无边界检查）
v.at(0); // 随机访问（边界检查）
v.front(); v.back(); // 首/尾元素
v.clear(); // 清空

// 1.2 deque —— 双端队列
deque<int> d = {1, 2};
d.push_front(0); // 头插
d.push_back(3); // 尾插
d.pop_front(); // 头删
d.pop_back(); // 尾删
d.front(); d.back(); // 首/尾访问
d.size(); d.empty();

// 1.3 list —— 双向链表
list<int> l = {1, 2, 3};
l.push_front(0);
l.push_back(4);
l.pop_front(); l.pop_back();
l.remove(2); // 删除所有值为2的元素
l.size(); l.empty();
l.front(); l.back();

// 1.4 set —— 有序唯一集合
set<int> s = {3, 1, 4, 1}; // 实际存储 {1,3,4}
s.insert(2); // 插入
s.erase(3); // 删除指定值
s.find(4); // 查找，返回迭代器，未找到返回 end()
s.count(1); // 计数（0或1）
s.size(); s.empty();
// 允许重复元素用 multiset，接口基本相同

// 1.5 map —— 有序键值对
map<string, int> ages;
ages["Alice"] = 25; // 插入/修改；注意：若 key 不存在，[] 会自动插入一个默认值(0)
ages["Bob"] = 30;
ages.erase("Alice"); // 删除
ages.find("Bob"); // 查找，不想触发自动插入就用 find 而不是 []
ages.count("Tom"); // 计数
ages.size(); ages.empty();
// 允许重复key用 multimap，接口基本相同

// 1.6 unordered_set —— 哈希无序集合
unordered_set<int> us = {3, 1, 4, 1};
us.insert(2);
us.erase(4);
us.find(3); // O(1) 查找
us.count(1);
us.size(); us.empty();

// 1.7 unordered_map —— 哈希无序键值对
unordered_map<string, int> scores;
scores["Tom"] = 95;
scores["Jerry"] = 88;
scores.erase("Tom");
scores.find("Jerry");
scores.count("Bob");
scores.size(); scores.empty();

// 1.8 stack —— 栈（LIFO）
stack<int> st;
st.push(1); // 入栈
st.push(2);
st.top(); // 查看栈顶
st.pop(); // 出栈（无返回值）
st.empty(); st.size();

// 1.9 priority_queue —— 优先队列（默认最大堆）
priority_queue<int> pq;
pq.push(5);
pq.push(1);
pq.push(10);
pq.top(); // 最大元素（10）
pq.pop(); // 移除堆顶
pq.empty(); pq.size();
// 想要最小堆：priority_queue<int, vector<int>, greater<int>> minPq;

// 1.10 pair —— 两个值的组合，不用专门定义 struct
pair<string, int> p1 = {"Alice", 25};
p1.first; // "Alice"
p1.second; // 25
pair<int, int> p2 = make_pair(1, 2); // 另一种构造写法

// 1.11 string —— 字符串（可以当成 char 的容器，替代 char* + strcpy/strcat 那一套）
string s2 = "hello";
s2 += " world"; // 拼接
s2.size(); s2.length(); // 长度（两个等价）
s2.empty();
s2[0]; // 下标访问
s2.substr(1, 3); // 从下标1开始取3个字符，"ell"
s2.find("wor"); // 查找子串，返回起始下标，找不到返回 string::npos
s2.replace(0, 5, "Hi"); // 替换
s2.append("!"); // 追加
to_string(42); // int -> string
stoi("123"); // string -> int
s2.c_str(); // 要传给 C 函数（如 fopen）时转成 const char*

// 1.12 array —— 固定大小数组（比原生C数组多了 .size() 等接口，但不能动态扩容）
array<int, 3> a = {1, 2, 3};
a.size();
a[0];
a.fill(0); // 全部填充为0

1.2 其他

对所有容器通用

VexDB 数据库安全自评价报告

Wed, 29 Jul 2026 18:51:00 +0800

版本号	日期	修改说明	编制人	审核人
1.0	2026.07.24	完成初稿	沈坤	-

1、核心资产

VexDB 的核心资产分为七类，覆盖数据、结构、访问、运行、审计、内存和密码资源，是数据库安全保护的主要对象。

核心资产	资产内容	资产价值
数据资产	业务数据、用户数据、交易数据等存储内容	数据库核心资源。泄露、篡改或丢失影响业务安全
数据库结构资产	模式、表、字段、索引、视图、存储过程、函数、约束等	描述数据组织和业务逻辑。非法修改影响业务正确性
数据库管理资产	用户、角色、权限、配置参数、安全策略等	控制访问范围和运行行为。错误配置影响整体安全
数据库运行资产	实例、进程、数据文件、日志文件及计算存储资源	支撑数据库服务运行。破坏导致服务不可用
数据库操作记录资产	访问日志、审计记录、运行日志、管理操作记录等	支撑安全分析、事件追踪和责任认定
数据库内存资产	内存中的业务数据、缓存、会话信息和认证凭证	运行过程中的敏感信息。泄露可能导致数据或凭证暴露
密码与密钥资产	加密密钥、口令摘要、认证凭证等密码资源	支撑身份认证和数据保护。泄露可能导致安全机制失效

核心资产的机密性、完整性和可用性，决定数据库安全运行和业务连续性。

2、安全风险和应对措施

VexDB 面临外部攻击、内部误操作、权限滥用和运行环境异常等风险，可能导致非法访问、数据泄露、数据篡改、身份冒用和服务不可用。主要风险与应对措施如下。

安全风险	风险描述	应对措施
非法访问风险	非授权主机连接数据库，获取非法访问入口	网络防火墙
身份认证风险	弱口令、凭证泄露或认证缺陷导致身份冒用	身份认证
通信安全风险	网络传输被窃听、伪造、重放或篡改	安全传输
权限控制风险	权限配置不当或权限提升导致越权访问	访问控制
数据安全风险	数据存储、传输、处理过程中发生泄露或篡改	透明加密、驱动加密、机密计算、动态脱敏、数据防篡改
密钥安全风险	密钥泄露、丢失或生命周期管理不足导致保护失效	密钥管理
操作追溯风险	数据访问和管理操作缺少记录，无法有效追责	数据库审计、数据防篡改
服务可用性风险	恶意请求或资源异常消耗导致性能下降或服务中断	资源安全
运行环境风险	不可信环境或异常运行环境导致数据暴露风险	驱动加密、机密计算、密钥管理

VexDB 通过网络防护、身份认证、访问控制、数据保护、密码保护、安全审计和资源管理等能力，降低非法访问、数据泄露、数据篡改和服务不可用等安全风险。

3、安全机制

VexDB 从接入、传输、访问、存储、计算、合规六个维度构建防御模型，各安全机制相互独立又相互配合。

数据库安全防篡改

Wed, 29 Jul 2026 10:04:00 +0800

CREATE SCHEMA s1 WITH BLOCKCHAIN;
CREATE TABLE s1.t1(c1 INT, c2 TEXT);
\d s1.t1
\d blockchain.s1_t1_hist

INSERT INTO s1.t1 VALUES(1, 'aa'), (3, 'bb'), (7, 'cc'), (10, 'dd');
SELECT *,hash FROM s1.t1;
SELECT * FROM blockchain.s1_t1_hist; # hahs_ins,hash_del,pre_hash
SELECT * FROM gs_global_chain; # relnsp,relname,relhash,globalhash,txcommand

SELECT ledger_hist_check('s1', 't1');
SELECT ledger_gchain_check('s1', 't1');

分布式

CREATE SCHEMA s1 WITH BLOCKCHAIN;
CREATE TABLE s1.t1(c1 INT, c2 TEXT);
SELECT create_distributed_table('s1.t1', 'c1');

INSERT INTO s1.t1 VALUES(1, 'aa'), (2, 'bb'), (3, 'cc'), (7, 'dd'), (10, 'ee');
SELECT *,hash FROM s1.t1;

SELECT * FROM blockchain.s1_t1_hist;
-- hahs_ins,hash_del,pre_hash, 其中，pre_hash没用上，无作用
SELECT * FROM gs_global_chain;
-- relnsp,relname,relhash,globalhash,txcommand

SELECT * FROM ledger_hist('s1', 't1');
SELECT * FROM ledger_gchain();

SELECT ledger_hist_check('s1', 't1');
SELECT ledger_hist_archive('s1', 't1');
SELECT ledger_hist_repair('s1', 't1');

SELECT ledger_gchain_check('s1', 't1');
SELECT ledger_gchain_archive();
SELECT ledger_gchain_repair('s1', 't1');

集中式

CREATE SCHEMA s1 WITH BLOCKCHAIN;
CREATE TABLE s1.t1(c1 INT, c2 TEXT);
INSERT INTO s1.t1 VALUES(1, 'aa'), (2, 'bb'), (3, 'cc'), (7, 'dd'), (10, 'ee');
SELECT *,hash FROM s1.t1;

SELECT * FROM blockchain.s1_t1_hist;
SELECT * FROM gs_global_chain;

SELECT ledger_hist_check('s1', 't1');
SELECT ledger_hist_archive('s1', 't1');
SELECT ledger_hist_repair('s1', 't1');

SELECT ledger_gchain_check('s1', 't1');
SELECT ledger_gchain_archive();
SELECT ledger_gchain_repair('s1', 't1');

-- 下面2个函数，不用适配，别动代码，告诉我当前表现
-- SELECT * FROM ledger_hist('s1', 't1');
-- SELECT * FROM ledger_gchain();

CREATE SCHEMA s1 WITH BLOCKCHAIN;
CREATE TABLE s1.t1(c1 INT, c2 TEXT);

国测 claude

Mon, 27 Jul 2026 19:03:00 +0800

VSCode Claude Code 扩展配置

本文记录如何在 VSCode 中配置 Claude Code 扩展，接入第三方（海量/glm）模型服务，无需在本机维护环境变量，扩展启动时自动注入。

配置位置

VSCode 用户级配置文件：

Windows：%APPDATA%\Code\User\settings.json
（即 C:\Users\<用户名>\AppData\Roaming\Code\User\settings.json）
macOS：~/Library/Application Support/Code/User/settings.json
Linux：~/.config/Code/User/settings.json

打开方式：VSCode 中按 Ctrl + , 打开设置 → 右上角「打开设置 (JSON)」图标，或直接 Ctrl + Shift + P 输入 Preferences: Open User Settings (JSON)。

完整配置

将以下内容合并进 settings.json（注意 JSON 语法，最后一项末尾不要多逗号）：

{
 "claudeCode.environmentVariables": [
 { "name": "ANTHROPIC_BASE_URL", "value": "http://172.16.105.104:3000" },
 { "name": "ANTHROPIC_AUTH_TOKEN", "value": "sk-hR1tQQloyPW0ax9b7404D51285Ae4737A118457535Fc33Ae" },
 { "name": "ANTHROPIC_MODEL", "value": "glm-5.2" },
 { "name": "ANTHROPIC_DEFAULT_OPUS_MODEL", "value": "glm-5.2" },
 { "name": "ANTHROPIC_DEFAULT_SONNET_MODEL", "value": "glm-5.2" },
 { "name": "ANTHROPIC_DEFAULT_HAIKU_MODEL", "value": "glm-5" },
 { "name": "CLAUDE_CODE_SUBAGENT_MODEL", "value": "glm-5" },
 { "name": "CLAUDE_CODE_EFFORT_LEVEL", "value": "max" }
 ],
 "claudeCode.preferredLocation": "panel"
}

环境变量说明

变量名	作用	说明
`ANTHROPIC_BASE_URL`	API 基础地址	指向第三方中转服务（兼容 Anthropic 协议）。海量外网网关示例：`http://172.16.105.104:3000`
`ANTHROPIC_AUTH_TOKEN`	鉴权令牌	中转服务下发的 `sk-xxx`，等价于官方的 API Key
`ANTHROPIC_MODEL`	默认模型	主对话使用的模型
`ANTHROPIC_DEFAULT_OPUS_MODEL`	Opus 档模型	覆盖官方 Opus 映射，通常设为最强模型
`ANTHROPIC_DEFAULT_SONNET_MODEL`	Sonnet 档模型	覆盖官方 Sonnet 映射，日常主力
`ANTHROPIC_DEFAULT_HAIKU_MODEL`	Haiku 档模型	覆盖官方 Haiku 映射，轻量快模型，用于补全/摘要
`CLAUDE_CODE_SUBAGENT_MODEL`	子 Agent 模型	Task/Explore 等子任务使用的模型，建议用快模型省钱
`CLAUDE_CODE_EFFORT_LEVEL`	推理强度	`max` 表示最高推理强度（思考最深），可选 `low/medium/high/max`

扩展项 claudeCode.preferredLocation：控制 Claude Code 面板的默认停靠位置，可选 panel（底部面板）或 editor（作为编辑器标签页）。

国测 vexdb

Mon, 27 Jul 2026 14:19:00 +0800

-- cn: 50000
-- dn1: 50005
-- dn2: 50010

vsql -d postgres -p 50000 -r

SELECT * FROM PG_DIST_NODE;

CREATE TABLE t1(c1 INT, c2 TEXT);
SELECT create_distributed_table('t1', 'c1');
-- 创建8个分片，dn1和dn2，每个dn有4个分片，即4个表，表名为 t1_$oid
SELECT * FROM pg_dist_shard; -- min和max是hash之后的值
SELECT * FROM pg_dist_shard_placement;
SELECT * FROM pg_dist_partition;

INSERT INTO t1 VALUES(1, 'aa'), (3, 'bb'), (7, 'cc'), (10, 'dd');

vsql -d postgres -p 50005 -r
SELECT oid,relname FROM pg_class WHERE relname like '%t1%';

vsql -d postgres -p 50010 -r
SELECT oid,relname FROM pg_class WHERE relname like '%t1%';

# cn
SELECT create_distributed_table('t1', 'c1');
 # --> shard 1 (dn1)
 SELECT worker_apply_shard_ddl_command (12042, 'CREATE TABLE public.t1 (c1 integer, c2 text) WITH (orientation=row, compression=no, fillfactor=80)');
 # dn1
 worker_apply_shard_ddl_command
 ddlnode = ParseTreeNode(sql)
 RelayEventExtendNames(ddlnode, sharid) # 在语法解析树中，把t1名称，修改为t1_$shardid
 ProcessUtilityParseTree
 SELECT worker_apply_shard_ddl_command (12042, 'ALTER TABLE public.t1 OWNER TO shenkun');
 # --> shard 2 (dn2)
 SELECT worker_apply_shard_ddl_command (12043, 'CREATE TABLE public.t1 (c1 integer, c2 text) WITH (orientation=row, compression=no, fillfactor=80)');
 SELECT worker_apply_shard_ddl_command (12043, 'ALTER TABLE public.t1 OWNER TO shenkun');
 # --> shared 3 (dn1)
 ...
 # --> 一共8个分片，每个分片2条SQL！

# cn
INSERT INTO t1 VALUES(1,'aa'),(3,'bb'),(7,'cc'),(10,'dd');
 exec_simple_query
 pg_parse_query
 pg_analyze_and_rewrite
 pg_plan_query
 [planner hook] distributed_planner
 CreateDistributedPlan
 CreateModifyPlan
 RouterInsertJob (deferredPruning=true)
 # 返回 CustomScan
 PortalStart
 ExecutorStart
 [DVecExecutorStart] DVecExecutorStart
 BeginCustomScan → DVecBeginScan
 DVecBeginModifyScan
 RegenerateTaskListForInsert
 BuildRoutesForInsert
 FindShardInterval
 ActiveShardPlacementList
 RebuildQueryStrings
 DeparseTaskQuery
 AppendShardIdToName # 生成改名后SQL
 PortalRun
 ExecutorRun
 [ExecutorRun_hook] DVecExecutorRun
 ExecCustomScan
 DVecExecScan
 AdaptiveExecutor
 RunDistributedExecution
 ...
 SendRemoteCommand
 StartRemoteTransactionBegin
 BeginTransactiionCommand # 生成：BEGIN ISOLATION LEVEL READ COMMITTED;
 AssignDistributedTransactionIdCommand # 生成：SELECT assign_distributed_transaction_id(0,20,'...');
 SendRemoteCommand # 一次发送2条事务SQL
 SendRemoteCommand
 PQsendQuery # INTO t1_$shardid ..
 CoordinatedRemoteTransactionsPrepare
 ..
 SendRemoteCommand # 发送 REPARE TRANSACTION ..
 SendRemoteCommand # 发送 COMMIT PREPARED ..
 # --> shard 1 (dn1)
 BEGIN ISOLATION LEVEL READ COMMITTED;
 SELECT assign_distributed_transaction_id(0,20,'...');
 INSERT INTO public.t1_12042 AS dvec_table_alias (c1, c2) VALUES (1,'aa'::text)
 REPARE TRANSACTION 'dvecx_...';
 COMMIT PREPARED 'dvecx_...';
 # 执行分布式事务
 INSERT INTO public.t1_12042 AS dvec_table_alias (c1, c2) VALUES (1,'aa'::text)
 # --> shard 2 (dn2)
 INSERT INTO public.t1_12043 AS dvec_table_alias (c1, c2) VALUES (10,'dd'::text)
 # --> shared 3 (d1)
 ...
 # --> 一共8个分片，其中4个分片，各收到1条INSERT语句
 # 多行在同一分片，INSERT语句合并

# cn
SELECT * FROM t1 WHERE c1 > 10;
 exec_simple_query
 pg_parse_query
 pg_analyze_and_rewrite
 pg_plan_query
 [planner hook] distributed_planner
 CreateDistributedPlan
 GetRouterPlanType
 (一造 multi-shard fan-out(非 router 计划))
 MultiLogicalPlanCreate (logical planner:建逻辑计划)
 CreatePhysicalDistributedPlan (physical planner)
 ├─ 为命中的每个分片建一个 Task(本表 8 个分片 → 8 个 Task)
 UpdateTaskQueryString
 DeparseTaskQuery
 deparse_shard_query
 AppendShardIdToName # t1 → t1_<shardId>
 # SELECT * + c1,c2 ; WHERE c1>10 → (c1 OPERATOR(pg_catalog.>) 10)
 # 包成 CustomScan 返回
 PortalStart
 ExecutorStart
 [DVecExecutorStart] DVecExecutorStart
 BeginCustomScan → DVecBeginScan
 PortalRun
 ExecutorRun
 [ExecutorRun_hook] DVecExecutorRun
 ExecCustomScan
 DVecExecScan
 AdaptiveExecutor
 RunDistributedExecution
 AssignTasksToConnectionsOrWorkerPool # 8 个 Task 分给 DN1/DN2 的连接
 ConnectionStateMachine
 StartRemoteTransactionBegin
 *发送: BEGIN + assign(每条 DN 连接首次用,只发一次)
 BeginTransactionCommand
 # 生成: BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED
 AssignDistributedTransactionIdCommand
 # 生成: SELECT assign_distributed_transaction_id(...)
 SendRemoteCommand → PQsendQuery
 *两条合并成一条发出
 # 发送: SELECT c1,c2 FROM t1_<shardId> WHERE (c1>10)
 # DN1 上 4 条 (12042/12044/12046/12048), DN2 上 4 条
 (COMMIT)
 RemoteTransactionCommit
 SendRemoteCommand → PQsendQuery
 # 只读 → 普通 COMMIT(无 PREPARE/COMMIT PREPARED,无 2PC)
 # COMMIT

 # --> shard 1 (dn1)
 SELECT c1, c2 FROM public.t1_12042 t1 WHERE (c2 OPERATOR(pg_catalog.>) 'cc'::text)

SELECT * FROM t1 WHERE c2 > 'cc';

密态：
 cn
 CREATE TABLE t1 (c1 ..)
 INSERT INTO t1 VALUES (..)
 SELECT c1,c2 FROM t1 WHERE ..
 dn
 CREATE TABLE t1_$shardid (c1 ..)
 INSERT INTO t1_$shardid VALUES (..) # values的值不变
 SELECT c1,c2 FROM t1_$shardid WHERE .. # WHERE子句不变

专利全密态索引

Wed, 15 Jul 2026 19:25:00 +0800

1 专利名称

一种基于可信执行环境的数据库密态索引访问方法、系统及介质

2 技术背景

全密态数据库：一种由数据库提供的安全特性，指数据库在处理数据的过程中，确保数据在传输、计算、存储等全生命周期阶段，于任何不可信的介质或环境中，始终处于加密状态。
全密态数据库实现方案：目前，业界较成熟的方案，是基于可信执行环境，实现全密态数据库，该方案主要分为2个模块：1)驱动加密：应用向数据库发送SQL语句时，应用侧的数据驱动自动加密SQL语句中的数据，数据库接收与处理数据密文。2)机密计算：数据库无法再密文上进行计算，将密文发送至可信执行环境（TEE）中，由可信模块完成解密与计算。
数据库索引结构：数据库中，最常见的索引为b+树索引。以tpcc测试模型为例，数据量低于100亿条时，b+树一般不超过4层。每一层的节点，即索引节点，是固定大小的page，分root index-page，internal index-page，leaf index-page。1个index-page中，存储多个index-item。其中，root和internal index-page中的index-item，存储数据和下一层index-page的位置。leaf index-page中的index-item，存储数据和table-page的位置。
加密性能：在加解密数据时，影响加密性能的因素中，加密次数的影响远高于数据长度。例如，1次加密8k数据，比40次加密200字节数据的性能高10+倍。
密态索引：在全密态数据库中，数据库只存储数据密文，在等值、范围查询等场景，为提高查询效率，避免全表扫描，需要在密文上构造索引。因此，需要见密文传输至可行执行环境TEE中，在TEE中临时解密数据，比较数据大小，构造索引。
现有方案缺陷：在构造密态索引时，现有方案存在以下缺陷：1)交互开销高：以索引元组为粒度，与TEE交互，交互次数多，交互开销高。2)加解密开销高：在索引页内比较元组大小时，需要多次解密索引元组。对于顶层的索引页，访问评率高，加解密频率也较高。3)内核修改多：为适配TEE，对索引构造、索引查询、并发控制等修改多，破坏生态兼容性等。

3 发明内容

发明目的：本发明针对在密文数据上构造索引、扫描索引的场景，提供一种通用的、高性能、低改造的方案，基于可信执行环境，大幅降低交互开销、加解密开销，并且，充分复用索引分裂、并发访问的机制，对内核侵入修改度低。
技术方案：
本发明的关键创新如下：

构造索引：应用插入数据时，驱动以字段为粒度，加密数据。数据库接收数据密文，TEE解密数据，构造索引，并以索引页为粒度，重新加密数据。
访问索引：结合索引的访问特点，每个index-item不独立加密与解密，每次以index-page为粒度加密与解密，降低加解密次数。
发送索引：数据库向TEE发生索引时，每次以index-page为粒度发送，降低交互次数。
缓存索引：在TEE中，针对索引中root和internal page访问频率高、修改频率低的特点，缓存解密后的page，降低解密次数、与TEE的交互次数。
内核改造：数据库中，访问索引时，只在需要比较大小时，才与TEE交互，保留已有索引分裂、并发访问机制。

以tpcc模型为例，当warhouse为10000时：

基表：bmsql_customer表中，数据行数为3亿，表大小约250G
索引：bmsql_customer主键索引中，index-item数为3亿，索引文件大小约9.5G，索引层数为4层，每层page数量分别：1、17、4400、114万，每个page中page-item数量约260个。插入1条数据，index-page平均分裂次数为0.0034次。

在该场景中，使用本发明的方案，考虑index-page分裂、TEE缓存偶尔未命中等所有可能产生额外交互、加密、解密的情况下：

场景	与TEE交互次数	加密次数（TEE内）	解密次数（TEE内）
插入1条数据	< 2.01	< 1.01	< 1.01
查询1条数据	< 2.01	0	< 1.01
删除1条数据	< 2.01	< 1.01	< 1.01

4 附图及附图的简单说明

4.1 密态索引结构

密态索引中，所有index-page中，只存储数据密文。在TEE中，以page为粒度加密，PageHeader、PageTail中，不存储用户数据，无需加密。
此处，以一个简单的3层索引为例，展示明文索引、密态索引的区别：

4.2 密态索引插入流程

在图1的示例中，向索引中插入1条数据，流程如下：

上述流程中，步骤12至20可通过缓存优化。以tpcc为例，index-item为3亿时，索引层数为4，索引文件大小约9.5G，root page数为1，internal page数为17+4000，缓存大小为31.38MB。

5 具体实施方式

5.1 创建密态索引

管理员：创建密钥 CREATE DATA KEY dk1(..);
数据库驱动：通过密钥服务或密码机生成密钥，缓存密钥，向数据库发送密钥信息
数据库：在系统表中，存储密钥信息，包括：密钥名、密钥Oid等。
管理员：创建加密表和索引：CREATE TABLE t1(c1 INT ENCRYPTED BY dk1, c2 TEXT)，CREATE INDEX i1 ON t1(c1);
数据库：存储加密信息，包括：表名、列名、密钥名等。

5.2 向索引插入1条数据

前置条件：已创建密态索引
应用：连接数据库
数据驱动：连接数据库，查询加密信息、密钥信息，并缓存
数据库驱动：从密钥服务或密码机获取密钥，与可信执行环境建立安全通道，并传输密钥
可信执行环境：缓存密钥
应用：向数据库存储数据：INSERT INTO t1 VALUES (13, ‘data1’);
数据库驱动：对SQL进行语法解析，识别加密列字段，并加密字段，并改写SQL：INSERT INTO t1 VALUESS (cipher[13], ‘data1’);
数据库：向基表t1插入数据(cipher[13], ‘data1’)，准备构造索引
数据库：向TEE中，发送密文 cipher[13]
可信执行环境：解密cipher[13]，获取明文(13)
可信执行环境：查找缓存的root page，如果未找到，请求数据库发送root page，解密并缓存root page
可信执行环境：在root page中，二分查找，获取internal page位置
可信执行环境：查找缓存的internal page，如果未找到，请求数据库发送internal page，解密并缓存internal page
可信执行环境：在internal page中，二分查找，获取leaf page位置
可信执行环境：请求数据库发送leaf page。解密leaf page
可信执行环境：如果leaf page已满，触发分裂流程，此处不展开说明
可信执行环境：在leaf pag中，二分查找，获取插入位置
可信执行环境：在leaf page中，插入数据(13, 基表t1中13的存储位置)
可信执行环境：加密leaf page，向数据库返回加密后的leaf page
数据库：重新存储加密后的leaf page

5.3 从索引中查找1条数据

查询流程，与插入流程大部分一致：

国测安全架构

Mon, 06 Jul 2026 16:40:00 +0800

4 安全架构

4.1 威胁模型

数据库运行在复杂的环境中，在计算、传输、存储数据等阶段，攻击者可利用硬件、软件等漏洞，威胁数据库安全。本文以数据库为核心，缩短攻击链路，排除攻击者身份演变、攻击阶段演进等因素，构造简化的威胁模型：

一、角色
1. 黑客
2. 内部运维人员
3. 内部研发人员
4. 系统维护人员
5. 供应链
6. 网络中间人
7. 机房管理人员
二、动机
1. 售卖获利
2. 勒索获利
3. 情报窃取
4. 蓄意报复
5. 规避审计
6. 炫耀技能
7. 人为过失
三、目标
1. 鉴别数据
2. 用户表
3. 系统表
4. 事务日志
5. 审计日志
6. 内存数据
7. 配置文件
四、技术
1. 不可信IP登录
2. 默认账户攻击
3. 过期账号攻击
4. 弱口令攻击
5. 密码泄露
6. 暴力破解
7. 凭证重放
8. 内存凭证残留
9. 流量伪造
10. 流量重放
11. 证书伪造
12. 未授权访问
13. 越权访问
14. 权限提升
15. 权限滥用
16. 磁盘窃取
17. 恶意软件
18. 操作系统隔离失效
19. 数据文件篡改
20. 供应链后门
21. 侧信道内存嗅探
22. 调试工具滥用
23. 特权用户窥探
24. 审计日志伪造
25. 攻击行为隐匿
26. 恶意操作抵赖
27. 合规审计证据缺失
五、分类
1. 欺骗
2. 篡改
3. 否认
4. 信息泄露
5. 拒绝服务
6. 权限提升

4.2 防御模型

针对威胁模型，本文从接入、传输、访问、存储、计算、合规6个维度，提供以下安全功能，构建防御模型：

接入安全：合法用户，才能接入数据库
- 网络防火墙
- 身份认证
传输安全：与数据库的通信数据，
- 安全传输
访问安全
- 访问控制
计算安全
- 驱动加密
- 机密计算
- 密码函数
存储安全
- 透明加密
合法合规
- 安全审计
- 动态脱敏
- 密钥管理

防御模型如下图所示：

ai

Fri, 03 Jul 2026 17:45:00 +0800

# 角色
你是一名 PostgreSQL 16 内核开发工程师，精通 src/backend/access/transam 及相关模块源码。

# 约束
1. 所有回答必须严格基于 PostgreSQL 16 Release 源码。
2. 解释机制时，必须引用具体的 .c/.h 文件路径和关键函数名。
3. 涉及数据结构时，请给出 struct 定义所在的头文件及字段含义。
4. 禁止使用“可能”、“通常”等模糊词汇描述内核行为；若不确定或版本不符，请明确告知。
5. 代码片段必须标注来源文件及大致行号范围（或函数上下文）。

# 当前任务
- 请梳理 XactBegin() 到 XactCommit() 的核心调用链，重点说明 CriticalSection 的作用。
- 解释 PG16 中 clog (pg_xact) 的写入与刷盘时机，结合 TransactionIdSetPageStatus 函数分析。
- MVCC 快照获取逻辑在 GetSnapshotData 中是如何与活跃事务列表交互的？
- 两阶段提交 (2PC) 在 PG16 中的状态持久化流程是什么？涉及哪些 WAL record 类型？

# 输出格式
1. 核心流程图/调用链（文字描述即可）
2. 关键源码位置（文件:函数）
3. 设计意图与权衡（Why it is implemented this way）
4. 相关 GUC 参数及其对代码路径的影响

工具 pg_xlogdump

Wed, 10 Jun 2026 18:58:00 +0800

# 单文件
pg_xlogdump 000000010000000000000001

# 多文件，指定lsn开始
pg_xlogdump -s 0/1000020 000000010000000000000001

# 多文件，整个目录
pg_xlogdump -p /opt/openGauss/data/pg_xlog

SELECT pg_current_wal_lsn();

\! pg_xlogdump -p $GAUSSHOME/data/pg_xlog -s

num=1640180680
printf "%X/%X\n" $((num >> 32)) $((num & 0xFFFFFFFF))
# 示例： 0/61c32bc8

pg_xlogdump -s 0/61c32bc8 -x 131128

printf "%x\n" 1640180680
# 示例： 61c32bc8
pg_xlogdump -s 000000010000000100000061 -x 131128

工具硬件资源

Fri, 29 May 2026 16:57:00 +0800

1 磁盘

# 各文件夹大小
du -sh ./* | sort -hr

强制访问控制

Mon, 16 Mar 2026 14:28:00 +0800

1 背景

1.1 友商分析

oracle
- 范围：行级、列级
- 实现：动态谓词过滤
金仓
- 范围：列级
mysql
- 无
sql server
- 范围：行级
- 实现：谓词过滤

oracle

基于标签的访问控制OLS：绝密HS、机密S、秘密C、公开P

https://docs.oracle.com/en/database/oracle/oracle-database/26/olsag/part1.html#GUID-C20C62AE-2A30-45F9-AEEA-52A0D3286FBA

-- 1 定义策略
SA_SYSDBA.CREATE_POLICY(policy_name => 'HR_POLICY', column_name => 'HR_LABEL')
-- 2 定义标签
SA_COMPONENTS.CREATE_LEVEL('HR_POLICY', 1000, 'PUBLIC', 'P');
-- 3 设置标签属性
SA_USER_ADMIN.SET_LEVELS('HR_POLICY', 'SCOTT', 'C', 'S');
SA_USER_ADMIN.SET_COMPARTMENTS('HR_POLICY', 'SCOTT', 'FIN');
-- 4 插入数据（主动定义标签）
INSERT INTO employees (emp_id, emp_name, salary, HR_LABEL)
VALUES (1001, 'John Doe', 50000, CHAR_TO_LABEL('HR_POLICY', 'C:FIN'));

sql server：无
kngbase
- 行级
- 链接：https://help.kingbase.com.cn/v8/safety/safety-guide/label-and-mac.html#id5
- 范围：table, view, index, procedure, function, package, sequence, trigger, synonym

claude

Fri, 06 Mar 2026 17:18:00 +0800

安装

wget https://unofficial-builds.nodejs.org/download/release/v20.18.1/node-v20.18.1-linux-x64-glibc-217.tar.xz

tar -Jxvf node-v20.18.1-linux-x64-glibc-217.tar.xz
mv node-v20.18.1-linux-x64-glibc-217 node-20

touch envn
echo '
export NODEHOME=`pwd`/node-20
export PATH=$NODEHOME/bin:$PATH
export LD_LIBRARY_PATH=$NODEHOME/lib:$LD_LIBRARY_PATH
' > envn
source envn

mkdir npm-global
npm config set prefix `pwd`/npm-global

npm config set prefix $NODEHOME/npm-global

echo 'export PATH=$NODEHOME/../npm-global/bin:$PATH' >> envn
source envn

npm pack @anthropic-ai/claude-code
npm install -g ./anthropic-ai-claude-code-2.1.162.tgz

claude --version

https://www.tapd.cn/43100420/markdown_wikis/show/#1143100420001007544

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN="sk-e435fe4629934fc892c226fc26d7ac92"
export ANTHROPIC_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-v4-flash
export CLAUDE_CODE_SUBAGENT_MODEL=deepseek-v4-flash
export CLAUDE_CODE_EFFORT_LEVEL=max

# 内网
export ANTHROPIC_BASE_URL=http://172.16.99.137:8081
export ANTHROPIC_AUTH_TOKEN=sk-q49Joop5Yz2BuS1ZPBPWJuCvwnS5elwKy9nP7PaLSi6fWrdy
export ANTHROPIC_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-v4-flash
export CLAUDE_CODE_SUBAGENT_MODEL=deepseek-v4-flash
export CLAUDE_CODE_EFFORT_LEVEL=max

# 内网 glm
export ANTHROPIC_BASE_URL=http://172.16.99.137:8081
export ANTHROPIC_AUTH_TOKEN=sk-q49Joop5Yz2BuS1ZPBPWJuCvwnS5elwKy9nP7PaLSi6fWrdy
export ANTHROPIC_MODEL=glm-5.2
export ANTHROPIC_DEFAULT_OPUS_MODEL=glm-5.2
export ANTHROPIC_DEFAULT_SONNET_MODEL=glm-5.2
export ANTHROPIC_DEFAULT_HAIKU_MODEL=glm-5
export CLAUDE_CODE_SUBAGENT_MODEL=glm-5
export CLAUDE_CODE_EFFORT_LEVEL=max

# 外网： http://172.16.105.104:3000

$env:ANTHROPIC_BASE_URL = "https://api.deepseek.com/anthropic"
$env:ANTHROPIC_AUTH_TOKEN = "sk-e435fe4629934fc892c226fc26d7ac92"
$env:ANTHROPIC_MODEL = "deepseek-v4-flash"
$env:ANTHROPIC_DEFAULT_OPUS_MODEL = "deepseek-v4-flash"
$env:ANTHROPIC_DEFAULT_SONNET_MODEL = "deepseek-v4-flash"
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL = "deepseek-v4-flash"
$env:CLAUDE_CODE_SUBAGENT_MODEL = "deepseek-v4-flash"
$env:CLAUDE_CODE_EFFORT_LEVEL = "max"

# 外网 海量
$env:ANTHROPIC_BASE_URL = "http://172.16.105.104:3000"
$env:ANTHROPIC_AUTH_TOKEN = "sk-q49Joop5Yz2BuS1ZPBPWJuCvwnS5elwKy9nP7PaLSi6fWrdy"
$env:ANTHROPIC_MODEL = "glm-5.2"
$env:ANTHROPIC_DEFAULT_OPUS_MODEL = "glm-5.2"
$env:ANTHROPIC_DEFAULT_SONNET_MODEL = "glm-5.2"
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL = "glm-5"
$env:CLAUDE_CODE_SUBAGENT_MODEL = "glm-5"
$env:CLAUDE_CODE_EFFORT_LEVEL = "max"

export ANTHROPIC_BASE_URL=http://172.16.105.104:3000
export ANTHROPIC_AUTH_TOKEN=sk-q49Joop5Yz2BuS1ZPBPWJuCvwnS5elwKy9nP7PaLSi6fWrdy
export ANTHROPIC_MODEL=glm-5.2
export ANTHROPIC_DEFAULT_OPUS_MODEL=glm-5.2
export ANTHROPIC_DEFAULT_SONNET_MODEL=glm-5.2
export ANTHROPIC_DEFAULT_HAIKU_MODEL=glm-5
export CLAUDE_CODE_SUBAGENT_MODEL=glm-5
export CLAUDE_CODE_EFFORT_LEVEL=max

# 外网 海量
$env:ANTHROPIC_BASE_URL = "http://172.16.105.104:3000"
$env:ANTHROPIC_AUTH_TOKEN = "sk-q49Joop5Yz2BuS1ZPBPWJuCvwnS5elwKy9nP7PaLSi6fWrdy"
$env:ANTHROPIC_MODEL = "deepseek-v4-flash"
$env:ANTHROPIC_DEFAULT_OPUS_MODEL = "deepseek-v4-flash"
$env:ANTHROPIC_DEFAULT_SONNET_MODEL = "deepseek-v4-flash"
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL = "deepseek-v4-flash"
$env:CLAUDE_CODE_SUBAGENT_MODEL = "deepseek-v4-flash"
$env:CLAUDE_CODE_EFFORT_LEVEL = "max"

export ANTHROPIC_BASE_URL=http://172.16.105.104:3000
export ANTHROPIC_AUTH_TOKEN=sk-q49Joop5Yz2BuS1ZPBPWJuCvwnS5elwKy9nP7PaLSi6fWrdy
export ANTHROPIC_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-v4-pro[1m]
export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-v4-flash
export CLAUDE_CODE_SUBAGENT_MODEL=deepseek-v4-flash
export CLAUDE_CODE_EFFORT_LEVEL=max

[System.Environment]::SetEnvironmentVariable("ANTHROPIC_BASE_URL", "https://api.deepseek.com/anthropic", "User")
[System.Environment]::SetEnvironmentVariable("ANTHROPIC_AUTH_TOKEN", "sk-e435fe4629934fc892c226fc26d7ac92", "User")
[System.Environment]::SetEnvironmentVariable("ANTHROPIC_MODEL", "deepseek-v4-pro[1m]", "User")
[System.Environment]::SetEnvironmentVariable("ANTHROPIC_DEFAULT_OPUS_MODEL", "deepseek-v4-pro[1m]", "User")
[System.Environment]::SetEnvironmentVariable("ANTHROPIC_DEFAULT_SONNET_MODEL", "deepseek-v4-pro[1m]", "User")
[System.Environment]::SetEnvironmentVariable("ANTHROPIC_DEFAULT_HAIKU_MODEL", "deepseek-v4-flash", "User")
[System.Environment]::SetEnvironmentVariable("CLAUDE_CODE_SUBAGENT_MODEL", "deepseek-v4-flash", "User")
[System.Environment]::SetEnvironmentVariable("CLAUDE_CODE_EFFORT_LEVEL", "max", "User")

# 安装nodejs
yum install -y nodejs

mkdir ~/.npm-global
npm config set prefix '~/.npm-global'
echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

# 安装claude
npm install -g @anthropic-ai/claude-code

# 验证
claude --version

cd /data/postgresql17

# 5. 启动 Claude Code 并进行首次认证
# 运行后，终端会提供一个链接，在浏览器中完成账号授权即可
claude

# 6. (可选但推荐) 生成项目记忆文件
# 在 Claude 交互界面中，输入以下命令，它会分析项目并生成 CLAUDE.md 文件
/init

# linux 使用代理
curl -L https://github.com/MetaCubeX/mihomo/releases/latest/download/mihomo-linux-amd64-compatible.gz | gunzip > /usr/local/bin/mihomo
chmod +x /usr/local/bin/mihomo

mkdir -p /etc/clash
curl -o /etc/clash/config.yaml http://43.135.139.219:9999/clash.yaml

# 3. 启动 Clash
nohup mihomo -f /etc/clash/config.yaml > /var/log/clash.log 2>&1 &

# 4. 设置代理环境变量（Clash 默认 mixed-port 7890）
export http_proxy=http://127.0.0.1:7890
export https_proxy=http://127.0.0.1:7890

# 5. 测试
curl -I https://www.google.com

git config --global user.name "shenkun"
git config --global user.email "shenkun@bupt.cn"

ssh-keygen -t rsa -C "shenkun@bupt.cn"
cat ~/.ssh/id_rsa

yum install proxychains-ng -y
echo "socks5 10.255.255.254 1080" >> /etc/proxychains.conf

# windows11 安装clash
https://github.com/clash-verge-rev/clash-verge-rev/releases

yum install -y shadowsocks-libev

cat > /etc/shadowsocks-libev/client.json << 'EOF'
{
"server": "43.135.139.219",
"server_port": 443,
"local_address": "127.0.0.1",
"local_port": 1080,
"password": "gauss@123",
"method": "aes-256-gcm"
}
EOF

ss-local -c /etc/shadowsocks-libev/client.json -f /var/run/ss-local.pid
export https_proxy=socks5://127.0.0.1:1080

# githup

使用

# 启动
claude
claude --resume # 恢复最近一次对话
claude --continue # 继续上一次对话
claude --model <name> # 指定模型
claude --dangerously-skip-permissions # 跳过所有权限确认
claude update

# 命令
/clear # 清楚所有对话
/compact # 压缩上下文，保留摘要
/rewind # 回滚上一次对话
/memory # 编辑记忆文件，记住偏好
/resume # 恢复历史会话
/context # 显示上下文窗口使用量

# 项目
/init 初始化项目，生成CLAUDE.md
/review # 代码审查
/commit # 提交

# 环境
/config # 调整主题、模型等
/model [name] # 切换模型
/permissions # 工具权限白名单
/doctor # 检查环境
/mcp
/cost # token用量和费用
/usage

# 扩展
/skill
/自定义skill

# 快捷键
| 快捷键 | 功能 |
| :--- | :--- |
| `Shift + Tab` | 循环切换三种模式：计划模式 → 默认模式 → 自动编辑模式 |
| `!command` | 直接在终端执行 bash 命令（不发给 AI） |
| `Ctrl + B` | 将阻塞的进程放到后台，继续对话 |
| `Esc Esc` | 双击 Esc 等同于 `/rewind` 回滚 |
| `Ctrl + V` | 粘贴图片到对话框 |
| `Option/Ctrl + Enter` | 输入框换行（Enter 是直接发送） |

模型名称	厂商	发布时间	核心亮点（精简）	定位/优势场景
GPT-5.6 (Sol/Terra/Luna)	OpenAI	2026.07.09	7月9日刚全球开放；三档分层+速度拨盘；Codex与ChatGPT合一	全能旗舰、超级智能体
GPT-5.5	OpenAI	2026.04.24	首个从零重训基础模型；100万tokens；MoE+Verifier架构	真实工作流、编程调试
DeepSeek-V4 (Pro/Flash)	深度求索	2026.04.24	万亿参数MoE开源；百万token原生上下文；成本仅OpenAI 1/100	开源性价比之王、Agent
Qwen3.7-Max	阿里巴巴	2026.05.20	国产Arena盲测第一；全域思考模式；Agentic Coding全球前三	国产旗舰、智能体编程
Claude Opus 4.7/4.8	Anthropic	2026 Q2	代码质量最优；长文本推理首选；WebDev Arena排名第一	编程审校、深度推理
Gemini 3.5 Pro	Google	2026.06	Artificial Analysis智能指数登顶；集成计算机使用(CU)能力	复杂推理、多模态科研
Grok 4 / 4.5	xAI	2026.05-07	实时接入X平台；编码与Agent能力持续强化；百亿~千亿参数	实时信息、社交分析
Kimi-K2.6	月之暗面	2026 H1	长文本办公统治级；JSON输出稳定；指令遵循能力强	办公自动化、Agent
GLM-5.1	智谱AI	2026 Q2	国产第一梯队；编程能力进入Top7；综合能力稳居前列	通用对话、编程辅助
豆包 2.1 Pro	字节跳动	2026.06	中文口语最自然；移动端交互最佳；多模态细节强	C端用户、内容创作
Meta Muse Spark 1.1	Meta	2026.07	首次开放Model API；正面争夺企业开发者市场	企业开发、开源生态
Llama 4	Meta	2026(预计)	开源生态标杆；多模态原生；社区微调最丰富	开源基座、定制微调

高质量专项全密态机密计算

Mon, 19 Jan 2026 18:37:00 +0800

1 架构

1.1 整体架构

全密态数据库是一种由数据库提供的安全特性，指数据库在处理数据的过程中，确保数据在传输、计算、存储等全生命周期阶段，于任何不可信的介质或环境中，始终处于加密状态。不可信环境包括：网络、内存、磁盘等。以常见的拓扑模型为例，在使用数据库的过程中，威胁面较广：

全密态数据库中，对于传输、存储安全，采用驱动加密方案。应用向数据库发送数据时，先在驱动中加密数据，再发送数据密文。应用从数据库接收数据时，先接收数据密文，再在驱动中解密数据。数据在网络、磁盘、服务端内存中，均处于加密状态。基本架构如下图所示：

全密态数据库中，对于计算安全，采用机密计算方案。驱动加密方案，解决传输、存储安全，但是，数据库端无法在密文上计算。为解决计算问题，业界有两种方案：

基于密码学算法的密文计算方案：通过密码学算法，让数据库在直接在密文上进行计算，例如保序加密、可搜索加密、同态加密等
基于硬件隔离的机密计算方案：在CPU、内存中，划分逻辑独立的可信执行环境，让数据库在可信执行环境中解密数据密文，进行计算。

在充分对比安全性、功能完备性、性能、实现难度等特点，选择机密计算方案。结合驱动加密方案、机密计算方案，全密态数据库整体架构如下图所示：

全密态数据库中，对于加密模型，采用多级密钥方案。数据由数据密钥加密，密钥由主密钥加密，主密钥由根密钥加密。在驱动加密模块中，只能获取数据密钥，无法获取主密钥。在更安全的加密方案中，驱动加密模块无法获取数据密钥，由硬件加密机加密。在数据库端，仅存储密钥信息，无法获取密钥。全密态数据库加密模型如下图所示：

2 流程

2.1 整体流程

使用全密态数据库时，用户需定义主密钥、数据密钥、加密表，在执行存储、查询数据时，全密态数据库自动完成加密、解密、计算等操作。完整的使用流程如图所示：

3 设计

3.1 驱动加密

3.2 机密计算

一、技术调研

纯软路线
- 同态加密
软硬路线
- x86
  - cpu
    - sgx：硬件
    - tdx：硬件
  - 固件
    - me：出厂自带
  - 软件
    - sgx driver
- amd
  - cpu
    - sev：Secure Encrypted Virtualization，CPU扩展电路，为每台虚拟机分配内存密钥，运行时加密整段内存。需BIOS开启。
    - sev-snp/sev-es
  - 固件
    - psp
  - 软件
    - kvm sev
- arm
  - cpu
    - trust-zone：每个核新增总线，
  - 固件
    - arm trusted fimware
  - 软件
    - op-tee
tee: https://github.com/OP-TEE/build

工具 python

Mon, 29 Dec 2025 14:31:00 +0800

查看python安装路径

python -c "import sys, os; print(os.path.dirname(sys.executable))"

python下载pgk

python -m pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名

操作系统 3 多进程与多线程

Wed, 17 Dec 2025 16:08:00 +0800

1 数据传输

1.1 传输场景

父子进程
陌生进程

1.2 传输接口

1.3 传输示例

2 并发控制

2.1 并发场景

整型
- 多写
- 一写多读
- 多写一读
- 多写多读
数据
- 多写
- 多读
- 一写多读
- 多写一读
- 多写多读

2.2 并发接口 (glibc)

一、自选锁

#include <pthread.h>

pthread_spinlock_t spin;

pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE);
pthread_spin_lock(&spin);
pthread_spin_unlock(&spin);

二、互斥锁

#include <pthread.h>

pthread_mutex_t lock;

pthread_mutexattr_t attr;
thread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);

pthread_mutex_init(&lock, &attr);
pthread_mutex_lock(&lock);
pthread_mutex_unlock(&lock);

三、读写锁

#include <pthread.h>

pthread_mutex_t rdlock;

pthread_mutexattr_t attr;
pthread_rwlockattr_init(&attr);
pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);

pthread_rwlock_init(&rdlock, &attr);
pthread_rwlock_rdlock(&rdlock);
pthread_rwlock_wrlock(&rdlock);
pthread_rwlock_unlock(&rdlock);

四、信号量

#include <semaphore.h>

sem_t sem;
sem_init(&sem, 0, 8);
sem_wait(&sem);
sem_post(&sem);

五、原子写

#include <pthread.h>/* C 11 */

volatile unsigned num = 0;

__atomic_store_n(&num, 8, __ATOMIC_SEQ_CST);
unsigned cur = __atomic_load_n(&num, __ATOMIC_SEQ_CST);

2.3 并发代码

整型数据

工具 gdb

Wed, 15 Oct 2025 16:41:00 +0800

查看某个进程占用的内存

ps -p 17286 --no-headers -o pid,comm,rss,%mem | awk '{printf "%-8s %-20s %8.2f MB %5s%%\n", $1, $2, $3/1024, $4}'

gdb调试进程或coredump文件时，变量取值出现’optimized out’时，关闭编译优化

# 以编译PG为例：
configure --enable-debug --disable-optimizations CFLAGS="-g -O0 -fno-inline -fno-omit-frame-pointer"

gdb启动调试阶段，自动执行命令

touch ~/.gdbinit
echo "handle SIGUSR2 nostop noprint" >> ~/.gdbinit

判断编译选项

readelf --debug-dump=info `which bin_name` | grep -E 'DW_AT_producer.*O[0-9]'

工具 git

Wed, 24 Sep 2025 16:35:00 +0800

git log --author=shenkun --oneline

x86

git status -uno | awk '{if (NR>1) print $3}' | grep src | xargs -I {} git add {}

arm

git status -uno | grep modified | awk '{if (NR>1) print $2}' | xargs -I {} git add {}

git tag -l

git ls-remote --tags origin

git fetch --tags

工具 tcpdump

Thu, 04 Sep 2025 15:22:00 +0800

tcpdump -i any -w ./vsql.pcap 'tcp port 5432'

Vastbase SSL安全传输

Thu, 28 Aug 2025 09:47:00 +0800

1 基于SSL证书实现身份认证

在应用与数据库传输数据时，为避免攻击者对数据进行窃听、篡改、伪造、重放等攻击，Vastbae支持采用SSL协议保障数据机密性与完整性。在SSL协议协商密钥的过程中，应用与数据库需通过证书验证对方身份，同时，该证书也可作为登入数据库的身份凭证。
此处介绍生成证书，并基于证书配置SSL协议，同时基于证书实现身份认证，操作流程可分为以下3个阶段：

一、生成私钥与证书
二、数据库端配置证书与私钥
三、应用端配置证书与私钥

一、生成私钥与证书

此处介绍基于openssl工具，生成自签名证书的流程

创建存放私钥与证书的文件夹

mkdir cadir
cd cadir
mkdir ./demoCA ./demoCA/newcerts ./demoCA/private
echo '01'>./demoCA/serial
touch ./demoCA/index.txt

配置openssl工具
从Vastbase安装包中，获取openssl工具以及openss配置文件。假设Vastbae安装包存放在$GAUSSHOME目录。

cp $GAUSSHOME/bin/openssl ./
export PATH=`pwd`:$PATH
which openssl # 确保openssl来源于Vastbase安装包，避免因版本不同造成证书不可用
openssl version

cp $GAUSSHOME/share/sslcert/gsql/openssl.cnf ./
export OPENSSL_CONF=`pwd`/openssl.cnf

创建CA私钥、CA证书

openssl ecparam -genkey -name SM2 -out demoCA/private/cakey.pem
openssl req -new -config openssl.cnf -key demoCA/private/cakey.pem -subj /C=CN/ST=BJ/L=HaiDian/O=VAST/OU=SEC/CN=CA -out cacert.req
openssl ca -selfsign -config openssl.cnf -batch -keyfile demoCA/private/cakey.pem -in cacert.req -out demoCA/cacert.pem

创建数据库私钥、数据库证书

e100

Tue, 29 Jul 2025 18:14:00 +0800

./configure --prefix=$PG_HOME --enable_debug --with-openssl --enable-cassert

make -sj 6 && make install

alias pmake='make -sj 6 && make install -sj'
alias pinit='rm -rf $PG_HOME/data && initdb -D $PG_HOME/data'
alias pstart='pg_ctl start -D $PG_HOME/data -l logfile'
alias pstop='pg_ctl stop -D $PG_HOME/data -l logfile'

pg_dump

Tue, 29 Jul 2025 18:07:00 +0800

1 使用方式

vsql -d vastbase -r

CREATE USER u1 PASSWORD 'u1.password';
CREATE USER u2 SYSADMIN PASSWORD 'u2.password';
CREATE USER u3 SUPERUSER PASSWORD 'u3.password';
SELECT rolname,rolsuper,rolsystemadmin FROM pg_authid ORDER BY rolname;

vsql -d vastbase -c "SELECT rolname,rolsuper,rolsystemadmin FROM pg_authid ORDER BY rolname;"

# 导出
vb_dumpall --roles-only -f ./u.sql

# 清理
vsql -d vastbase -c " DROP USER IF EXISTS u1,u2,u3; "

# 恢复
vsql -d vastbase -f ./u.sql

vsql -d vastbase -c "SELECT rolname,rolsuper,rolsystemadmin FROM pg_authid ORDER BY rolname;"

libpq

Mon, 28 Jul 2025 10:38:00 +0800

1 libpq编程

1.1 配置数据库

安装数据库
```
# 假设安装目录为
$PG_HOME
```
启动数据库
```
# 假设数据目录为
$PG_HOME/data
```

配置数据库

echo 'host all u1 0.0.0.0/0 md5' >> $PG_HOME/data/pg_hba.conf
echo "listen_addresses='0.0.0.0'" >> $PG_HOME/data/postgresql.conf
pg_ctl reload -D $PG_HOME/data

创建用户

psql -d postgres -c "create user u1 password 'u1.password';"

# 验证一下
psql -h 127.0.0.1 -p 5432 -d postgres -U u1 -W 'u1.password' -c '\d'

1.2 编写libpq demo

生成源文件

touch pq.c

# 复制 1.3 章节的源码 到 pq.c中

# 配置环境变量
export LD_LIBRARY_PATH=$PG_HOME/lib:$LD_LIBRARH_PATH

编译

gcc pq.c -o pq -I$PG_HOME/include -L$PG_HOME/lib -lpq

执行

海量 9 用例 E100审计

Fri, 25 Jul 2025 15:33:00 +0800

1 adt_scope_ddl

/*
=============================
Operate
 create
 alter
 drop
 truncate

 prepare
 dealocate

 abort
 begin
 release savepoint

 analyze
 checkpoint
 commit
 commit prepared
 end
 rollback
 rollback prepare
 prepare
 prepare transcation
 rollback to savepoint
 savepoint
 start transaction

 call
 execute

 close

 explain
 cluster
 comment

 copy

 discard
 do
 declare

 move
 fetch

 grant
 revoke

 import

 listen
 notify
 unlisten

 load

 lock

 reassign
 refresh
 reindex

 reset
 set
 set constraints
 set role
 set session authorization
 set transcation
 show

 values
Object:
 system

 user
 role
 group

 database
 table space
 schema
 table
 temp table
 forgien table
 index
 view
 materialized view
 sequence

 function
 procedure
 trigger
 aggregate

 larger object

 domain
 type
 cast
 conversion
 collation
 language
 rule

 forgien data wrapper
 server
 user mapping

 publication
 subscription

 privileges
 policy

 statistics
 routine

 text search configuration
 text search dictionary
 text search parser
 text search template

 operator
 operator class
 operator family
 access method

 extension
-- =============================
*/

-- fdw
\c atlasdb
CREATE EXTENSION postgres_fdw;
CREATE USER u1 PASSWORD 'u1.password';
CREATE SERVER s1 FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host '172.16.100.134', port '5432', dbname 'fdb1');
GRANT ALL ON FOREIGN SERVER s1 TO u1;
set role u1;
CREATE FOREIGN TABLE t1 (c1 INT) SERVER s1 OPTIONS (schema_name 'public', table_name 'ft1');
CREATE USER MAPPING FOR u1 SERVER s1 OPTIONS (user 'fu1', password 'fu1.password');

-- common
CREATE TABLE tbl(c1 INT, c2 TEXT);
INSERT INTO tbl VALUES(generate_series(1, 100), 'bbbbbbbbb');

-- cursor | declare,fetch,move,close | (must in transaction block)
BEGIN;
DECLARE cu1 CURSOR FOR SELECT * FROM tbl; -- consider it as a cache for select result
FETCH 3 FROM cu1;
FETCH 3 FROM cu1;
MOVE FORWARD 2 FROM cu1;
CLOSE cu1;
COMMIT;

-- channel | listen,unlisten,notify
-- session 1
LISTEN ch1;
-- session 2 --> session 1, session 1 receive and cache message
NOTIFY ch1, 'hello';
SELECT pg_notify('ch1', 'hello' || 'a');
UNLISTEN ch1;

-- table | create,alter(rename,move),drop,lock,insert,update,select,delete
CREATE TABLE tb1(c1 INT);
ALTER TABLE tb1 ADD COLUMN c3(INT);
ALTER TABLE tb1 RENAME COLUMN c3 TO c2;
BEGIN;
LOCK TABLE tb1 IN ACCESS EXCLUSIVE MODE;
COMMIT;
DROP TABLE tb1;

-- materialized view
CREATE MATERIALIZED VIEW mv1 AS SELECT * FROM tbl;

-- dictionary & configuration |
CREATE TEXT SEARCH DICTIONARY tsd1 (
 TEMPLATE = snowball,
 language = english
);
ALTER TEXT SEARCH DICTIONARY tsd1 (stopwords = english);
CREATE TEXT SEARCH CONFIGURATION tsc1 (copy = english);
ALTER TEXT SEARCH CONFIGURATION tsc1 ALTER MAPPING FOR asciiword, asciihword, hword_asciipart WITH tsd1, simple;
SELECT to_tsvector('tsc1', 'abc bb cc bb');
DROP TEXT SEARCH CONFIGURATION tsc1;
DROP TEXT SEARCH DICTIONARY tsd1;

-- domain | create,alter,drop
CREATE DOMAIN do1 AS TEXT CONSTRAINT c1 CHECK ( VALUE ~ '^[0-9]+$' ) DEFAULT '3'; -- consider a group of 'check / not null / default' for column
ALTER DOMAIN do1 ADD CONSTRAINT c2 CHECK (LEFT(VALUE, 1) < '5');
 CREATE TABLE t1(c1 do1);
 INSERT INTO t1 VALUES ('12');
 INSERT INTO t1 VALUES ('89');
 INSERT INTO t1 VALUES (default);
 DROP TABLE t1;
DROP DOMAIN do1;

-- conversion | create | (need define c code)
-- CREATE FUNCTION f1(integer, cstring, integer, cstring) RETURNS integer AS 'latin1_utf8', 'latin1_to_utf8' LANGUAGE C STRICT;
-- CREATE CONVERSION co1 FOR 'LATIN1' TO 'UTF8' FROM f1;
-- SELECT CONVERT('\xe4\xf6\xfc'::bytea, 'latin1_utf8_cnv');
-- DROP CONVERSION co1;
-- DROP FUNCTION f1;

-- user
CREATE USER u1 PASSWORD 'u1.password';
CREATE USER u2 PASSWORD 'u2.password';
CREATE USER u3 PASSWORD 'u2.password';
ALTER USER u1 PASSWORD 'u1.newpass';
DROP USER u1;
DROP USER IF EXISTS u1,u2,u3,u4;

-- type
CREATE TYPE int_2 AS (a INT, b INT);

-- synonym (only oracle)
CREATE TABLE t1 (c1 INT);
CREATE SYNONYM s1 FOR t1;
CREATE PUBLIC SYNONYM ps1 FOR t1;
SELECT * FROM s1;
SELECT * FROM ps1;
DROP SYNONYM s1;
DROP SYNONYM ps1;

-- aggregate
CREATE FUNCTION f_add_a_int(state bigint[], val int)
RETURNS bigint[] LANGUAGE sql AS
$$ SELECT ARRAY[state[1] + val, state[2] + 1] $$;

CREATE FUNCTION f_avg_final(state bigint[])
RETURNS numeric LANGUAGE sql AS
$$ SELECT state[1]::numeric / state[2] $$;

CREATE AGGREGATE a_int_avg(int) (
 SFUNC = f_add_a_int,
 STYPE = bigint[],
 FINALFUNC = f_avg_final,
 INITCOND = '{0,0}'
);

SELECT a_int_avg(v) FROM generate_series(1,6) v;

DROP AGGREGATE a_int_avg(int);
DROP FUNCTION f_add_a_int;
DROP FUNCTION f_avg_final;

2 adt_scope_dcl

3 adt_scope_dml

4 adt_scope_dql

5 adt_scope_tcl

6 adt_scope_func

7 adt_scope_mng

8 adt_scope_misc

jdbc

Thu, 24 Jul 2025 19:03:00 +0800

1 使用JDBC的流程

准备java环境
准备jdbc驱动
编写java代码
执行java代码

2 使用JDBC

2.1 准备java环境

安装java工具包

sudo yum install -y java-1.8.0-openjdk java-1.8.0-openjdk-devel

验证java安装成功

java -version
# openjdk version "1.8.0_382" : 8表示java 8

执行java demo

# 编写代码
echo '
public class Demo {
 public static void main(String[] args) {
 System.out.println("Hello World");
 }
}
' >> Demo.java
# 编译代码
javac Demo.java
# 执行
java Demo

2.2 准备jdbc驱动

touch jdbc
cd jdbc
mkdir jars
cd jars
wget https://jdbc.postgresql.org/download/postgresql-42.7.7.jar

目录架构：
|-- jdbc
 |-- jars
 |-- postgresql-42.7.7.jar

https://polydistortion.net/bc/index.html

海量 9 设计 E100审计

Tue, 22 Jul 2025 14:28:00 +0800

1 E100审计功能

1.1 功能简述

【审计功能】
审计是重要的安全特性，核心功能是收集数据库内的事件，例如：登录用户、创建对象、查询数据等，根据事件生成与审计日志，存储审计日志，向用户提供日志查询接口。使用方式请看需求文档。

【审计架构】
审计整体架构如下图所示：（“线程“替换为“进程”，原图不小心弄丢了，不好修改了，将就看）

【审计流程】

1.2 实现方案

一、启动审计进程

1. 启动postmaster进程 # PostmasterMain
 2. 加载GUC参数 # SelectConfigFiles
 2.1 '---加载审计GUC---'
 3. 创建共享内存和信号量 # reset_shared -> CreateSharedMemoryAndSemaphores
 3.1 计算共享内存总大小
 '计算审计共享内存大小：根据GUC配置'
 3.2 创建共享内存 # PGSharedMemoryCreate
 3.3 创建LwLock # CreateLWLocks
 3.4 初始化wal-buffer共享内存 # XLOGShmemInit
 3.5 初始化share-buffer共享内存 # InitBufferPool
 3.6 '如果开启审计：初始化审计共享内存：划分共享内存，包括audit-buffer'
 4. 启动sys-log进程 # SysLogger_Start
 5. '如果开启审计：初始化审计模块'
 5.1 '日志目录：检验与创建审计日志目录'
 5.2 '日志文件：每次重启，使用新的日志文件，方便用户单个删除日志文件'
 5.3 '内存上下文：创建审计全局内存上下文'
 5.4 '审计缓存区：初始化audit-buffer'
 5.5 '审计文件：初始化审计文件（并发write, read, delete日志）'
 5.6 '回调函数：在执行DDL、计划、函数等关键函数中，注册生成审计事件、日志的回调函数' # 后面详细介绍
 6. '如果开启审计：启动审计进程'
 6.1 '信号：注册信号处理函数：sighup, sigquit, sigusr1'
 6.2 '显示：设置ps命令显示的进程信息'
 6.3 主循环
 6.4 '等待事件：关键是timeout'
 6.5 '存储日志：读取audit-buffer中待落盘的日志，并存储' # 后面详细介绍
 6.6 '调整速率：按照每次落盘数据的长度，动态调整timeout'
 连续多次为0，timeout依次变为1ms, 100ms, 1s
 单次落盘长度大于16m，timeout=0
 7. '主循环' # ServerLoop
 7.1 接收客户端连接 # select
 7.2 创建postgres进程 # BackendStartup -> BackendRun -> PostgresMain
 7.3 检查与重启sys-log进程 # SysLogger_Start
 7.4 '检查与重启审计进程'
 7.5 检查与重启checkpointer进程 # StartCheckpointer
 7.6 检查与重启wal-writer进程 # StartWalWriter

二、收集审计事件

目前，只有以下2类进程，会生成审计事件：

海量 9 需求 E100审计

Fri, 18 Jul 2025 10:50:00 +0800

1 简介

1.1 目的

审计是重要的安全特性，功能是收集数据库内的事件，例如创建对象、查询数据等，根据事件生成与存储审计日志，并向用户提供查询审计日志的接口。

在303.7版本，E100首次引入审计特性，本文介绍E100审计特性的对外接口、功能约束、使用方式等信息。

1.2 适用范围

E100，303.7及之后的版本

1.3 术语定义、首字母缩写词和缩略语

无

1.3 参考资料

G100审计特性：https://docs.vastdata.com.cn/zh_CN/VastbaseG100/V3.0.8/1/2f4fb0e4adcc49f8b19dd4710f2a6549
Oracle审计特性：https://docs.oracle.com/en/database/oracle/oracle-database/23/dbseg/part_6.html
开源组件pgaudit：https://www.modb.pro/db/105894
G100审计重构方案：https://doc.weixin.qq.com/doc/w3_AdwAfAa7AFkCNFLkO0AXJSUK7CICd?scode=AHUAfwdSAA8DKRU1G1AdwAfAa7AFk&version=4.1.38.6011&platform=win
pg 14完整语法：https://www.postgresql.org/docs/14/sql-commands.html

2 E100审计特性

2.1 功能简述

【审计特性】
审计特性，主要功能是记录数据库内的各种事件，并向用户提供查询事件的接口。事件包括：

启动、恢复、切换、停止集群
登录、注销账号
创建、修改、删除数据库对象，包括：DATABASE、SCHEMA、TABLE等
插入、更新、删除、查询关系表
…

【审计事件】
数据库内发生的事件，都可描述为<主体><操作><客体>

主体：一般是数据库用户
客体：集群、账号、数据对象等
操作：针对不同客体，操作类型不一样。比如，对于TABLE，操作类型有：CREATE, INSERT, SELECT等。

【审计日志】
发生事件时，审计特性会收集事件中的信息，将事件封装审计日志，审计日志中的关键内容包括：

主体信息：用户名
操作信息：操作类型、操作时间、操作的SQL语句等
客体信息：客体类型、客体名称、客体属于哪个database、客体属于哪个schema

【审计流程】
使用审计特性时，主要包括以下几个流程：

配置审计功能：用户提前配置审计范围，即配置哪些事件需被审计。
生成审计日志：用户操作数据库时，产生审计事件，例如创建表、删除表等。内核收集事件信息，生成审计日志。
存储审计日志：内核存储审计日志至磁盘。
查询审计日志：用户查询审计日志，内核从磁盘读取审计日志。
删除审计日志

一个简单示例如下图所示：

-- 1. 配置审计功能：确定哪些事件需审计
-- 2. 生成审计日志：用户执行SQL，产生事件<用户><创建><表>，根据事件生成日志
CREATE TABLE t1 (c1 INT, c2 TEXT);
-- 3. 存储审计日志：内核自动存储日志
-- 4. 查询审计日志
SELECT * FROM pg_audit_log();
 -- 预期输出（横向输出）
 -[ RECORD 1 ]---------------------------------
 scope |
 subject | u1 -- 主体信息：用户名
 optype | create -- 操作信息：create操作
 optime | 2025-07-18 18:15:17.400009+08 -- 操作时间
 opresult |
 object | table -- 客体信息：客体类型
 objdb | postgres -- 客体信息：客体属于哪个database
 objnsp | public -- 客体信息：客体属于哪个schema
 objname | t1 -- 客体信息：客体名称
 opxid |
 optid |
 pid |
 sql | create table t1(c1 int); -- 触发操作的SQL
 extra |

【友商对比】
对比oracle、opengauss/g100、pgaudit

分享编写需求/设计文档的个人经验

Tue, 15 Jul 2025 10:54:00 +0800

1 简介

1.1 分享的主题

分享一些编写需求、设计文档经验

1.2 分享的背景

背景：我写的需求文档，（相对）还算详细，所以有此次分享
- 308.1，profile功能的需求文档：https://www.tapd.cn/60475194/markdown_wikis/show/#1160475194001007196
根因：前公司流程繁重，被迫养成这种习惯。
分享的内容：可分享的干货不多，我觉得，在写文档的过程中，大部分人想的很详细，只是没有编写到文档中，毕竟每个人都有自己的编写风格。所以，本文的重点，是介绍前公司流程与要求，并以我做过的需求为例，为大家提供一点参考。
分享人经历：交过10+个不算小的需求，完整写过10+次需求与设计文档，格式与海量的接近。
分享的局限：交付的需求，主要是安全方向，也涉及SQL、存储等多个模块，所以，本文主要以安全需求的角度写，其他模块的需求不一定适用。

1.3 前公司的流程

与海量相比，前公司的交付流程，几乎一样：

客户：提出需求
产品、项目、测试、架构等：审核需求
开发：撰写需求/设计文档
各角色：评审需求/设计文档
开发：编写代码
…

其中，在4.评审需求/设计文档环节，前公司区别较大：

一、评审人员多

编号	角色	评审人	目的
1	开发	安全组、SQL组、存储组、运维组、..	避免影响其他模块，协助发现风险
2	测试	测试人、测试组长	学习新需求，识别测试重点
3	架构	架构设计	避免影响其他模块，确保后向兼容
4	资料	资料优化、资料审核	学习新需求
5	用例	用例审核	确保各种check可看护功能
6	其他	流程提升	-

二、评审通过难
1. 组内评审
2. 线上评审：上述所有角色会上评审，不过，一般很多人会议冲突，关键靠线下评审
3. 线下评审（关键流程）：各类角色共10+必选评审人，通过在线需求文档、设计文档了解需求，提出疑问，提出意见。开发分析解决后，找提出人确认意见，才算闭环。最后，所有必选评审人评审通过，才算完成流程。

在这种流程中，需求与设计文档，要满足很多要求：

普适：考虑到其他组开发、测试、资料等角色，不熟悉本领域的基础知识，所以，需要详细介绍相关原理，很多原理需要从头介绍
完整：要充分例举所有可能涉及风险，否则，评审人会认为未考虑到

举例：做了1个需求，可以为表设置加密属性，需要考虑：系统表、用户表（atore表、ustore表、分区表、临时表、toast表、unlogged表、segment表、hashbuckent表、物化视图…）

2 需求文档写作思路

2.1 分析过程

首先，客户提出需求，很多需求不够清晰。

示例：

profile原始需求：

目前对于数据库用户的管理方式不够便捷，无法像Oracle为用户赋予一组安全策略。一些属性如密码有效期、密码过期天数、密码尝试次数等也只能全局设定，无法指定用户配置。

然后，以我的个人习惯，分析需求的流程如下：

海量 9 接口 E100审计

Tue, 17 Jun 2025 18:18:00 +0800

配置审计功能
通过GUC配置审计功能，新增GUC如下：

编号	参数名	默认值	取值范围	功能
1	enable_audit	off	on, off	控制是否开启审计功能
2	aduit_directory	空	任意绝对路径	审计日志存储目录，确保数据库用户有权访问。如果取值为空，则默认存储于”数据目录/vb_audit”下
3	audit_directory_size	64M	[64M, -]	审计日志目录最大空间，如果文件目录达到限制时，最旧的日志文件将被新文件覆盖
4	audit_scope	ddl	all, ddl, insert, update, select, delete, function	审计范围。可设置多个范围，示例：”ddl, update, delete”
5	audit_buffer_size	16M	[1M, 1G]	内存中，审计日志缓冲区大小
6	audit_detail	basic,event,sql	basic,event, sql	控制审计日志详细程度
7	audit_unclassfied	on

启动审计功能
设置审计参数后，重启数据库，内核关键变化如下：

申请共享内存：工作线程生成日志后，将日志写入共享内存，该内存为审计日志缓冲区，缓冲区大小由GUC参数audit_buffer_size控制
新增进程：新增1个线程，负责将审计缓存区中的日志，存储至文件

生成审计日志
执行SQL语句时，如果SQL语句在审计范围内，内核一般会生成1条审计日志，如果SQL语句较复杂，语句中多个子操作会生成多条审计日志。

审计日志中，记录的内容如下：

日志字段	示例	解释
主体类型	user	目前，主体类型只支持用户类型
主体名称	u1	执行操作的用户，即执行SQL前，与数据库建立连接的用户
操作类型	create	针对不同类型的对象，操作不同，例如，针对表有create, insert, select, ..等操作
操作时间	2025-05-01 12:00:01 678956	格式：年-月-日时-分-秒微秒
操作XID	20000	事务ID
操作LSN	0/170F5F0	该日志对应的SQL语句，最新生成的XLOG的写入位置
对象类型	table	数据库对象类型，包括database, schema, table, view, …
对象名称	t1	数据库对象名称
对象数据库	db1	对象属于哪个database
对象命名空间	sch1	对象属于哪个schema
SQL语句	CREATE TABLE t1(c1 INT, c2 TEXT)	执行操作的原始SQL语句

存储审计日志
在审计目录下，审计文件设计如下：

命名：格式为：adt_年_月日_时分_秒_微秒.alog，文件名中包含文件创建时间
示例：

flamegraph 火焰图

Mon, 09 Jun 2025 11:54:00 +0800

yum install perf
git clone https://github.com/brendangregg/FlameGraph.git

touch perf.sh

pids=$(pgrep $1 | head -n 4)
rm -rf ./tmp_graph
mkdir ./tmp_graph
for pid in $pids; do
 echo "-- collecting data for $pid"
 perf record -F 600 -p $pid -g -- sleep 5
 perf script -i perf.data > ./tmp_graph/perf.unfold.$pid
 ./flame/stackcollapse-perf.pl ./tmp_graph/perf.unfold.$pid > ./tmp_graph/perf.folded.$pid
done
cat ./tmp_graph/perf.folded.* > ./tmp_graph/all.folded
./flame/flamegraph.pl ./tmp_graph/all.folded > ./all.svg

sh perf.sh 进程名

rm -rf ./tmp_graph
mkdir ./tmp_graph
pid=$1
echo "-- collecting data for $pid"
perf record -F 600 -p $pid -g -- sleep 5
perf script -i perf.data > ./tmp_graph/perf.unfold.$pid
./flame/stackcollapse-perf.pl ./tmp_graph/perf.unfold.$pid > ./tmp_graph/perf.folded.$pid
done
cat ./tmp_graph/perf.folded.* > ./tmp_graph/all.folded
./flame/flamegraph.pl ./tmp_graph/all.folded > ./all.svg

PostgreSQL fdw

Thu, 29 May 2025 14:20:00 +0800

1 E100 fdw

+----
| User
|

定义外表

-- \c atlasdb

-- ALTER SYSTEM SET password_encryption = 'scram-sha-256';
-- SELECT pg_reload_conf();
-- SHOW password_encryption;

-- 外部数据库：fdb1
CREATE DATABASE fdb1;
CREATE USER fu1 PASSWORd 'QAZ2wsx@123';
\c fdb1
set role fu1;
CREATE TABLE ft1 (c1 INT);
INSERT INTO ft1 VALUES (11);
reset role;

-- 配置本地数据库
\c atlasdb
CREATE EXTENSION postgres_fdw;

CREATE USER u1 PASSWORD 'u1.password';
CREATE SERVER s1 FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host '172.16.100.134', port '5432', dbname 'fdb1');
GRANT ALL ON FOREIGN SERVER s1 TO u1;

set role u1;
CREATE FOREIGN TABLE t1 (c1 INT) SERVER s1 OPTIONS (schema_name 'public', table_name 'ft1');
CREATE USER MAPPING FOR u1 SERVER s1 OPTIONS (user 'fu1', password 'QAZ2wsx@123');

-- 配置远程登录
echo 'host all u1 0.0.0.0/0 md5' >> $PG_HOME/data/atlasdb_hba.conf
echo 'host all fu1 0.0.0.0/0 md5' >> $PG_HOME/data/atlasdb_hba.conf
echo "listen_addresses='0.0.0.0'" >> $PG_HOME/data/atlasdb.conf
pstop
pstart

-- 访问外表
set role u1;
SELECT * FROM t1;

SELECT * FROM pg_user_mapping;

-- clean
DROP SERVER s1 CASCADE;
DROP USER u1;

DROP DATABASE fdb1;
DROP USER fu1;

2 G100 fdw

安装外部集群

工具多线程 thread

Thu, 22 May 2025 19:29:00 +0800

1 多线程框架

gcc thd.c -lpthread -o thd

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>

bool prtlog = true;

#define ASSERT(cond) \
 if (!(cond)) {printf("ASSERT | file: %s line: %d func: %s\n", __FILE__, __LINE__, __FUNCTION__); exit(-1);}

#define LOG(thdctl, fmt, ...) \
 do { \
 if (prtlog) { \
 char data_[2048]; \
 snprintf(data_, 2048, (fmt), ##__VA_ARGS__); \
 thdctl != NULL ? \
 printf(" >%-3d %s\n", ((ThdCtl *)(thdctl))->id, data_) : \
 printf("%s\n", data_); \
 } \
 } while (0)

/* ---------------------------------------------------------------------- */
typedef struct ThdCtl ThdCtl;
typedef struct ThdData ThdData;
typedef void (*ThdHookFunc)(ThdCtl *thdctl, ThdData *data);
struct ThdCtl {
 /* thread info */
 int stat;
 pthread_t thd;
 int id;

 /* thread function */
 ThdHookFunc init_func;
 ThdHookFunc exec_func;
 ThdHookFunc exit_func;
 ThdData *data;

 /* thread control */
 bool iswait;
 sem_t wait;
};
typedef struct {
 int thdnum;
 ThdCtl *thdarr[10000];
} ProCtl;
/* ---------------------------------------------------------------------- */
void multi_execute(ThdHookFunc initfunc, ThdHookFunc execfunc, ThdHookFunc exitfunc, int thdnum, ThdData *dataarr);

typedef struct ThdData {
 int id;

} ThdData;

void init(ThdCtl *thdctl, ThdData *data)
{
 LOG(thdctl, "init");

 data->id = thdctl->id;
}

void execute(ThdCtl *thdctl, ThdData *data)
{
 LOG(thdctl, "execute, id: %d", data->id);
}

void finish(ThdCtl *thdctl, ThdData *data)
{
 LOG(thdctl, "finish, id: %d", data->id);
}

int main()
{
 ThdData datas[10] = {0};

 multi_execute(init, execute, finish, 10, datas);

 return 0;
}

/* ---------------------------------------------------------------------- */

void *thread_main(void *arg)
{
 ThdCtl *tctl = (ThdCtl *)arg;

 if (tctl->init_func != NULL) {
 tctl->init_func(tctl, tctl->data);
 }

 /* wait to be wake up */
 // LOG(tctl, "sleep");
 sem_wait(&tctl->wait);

 /* wake up now */
 // LOG(tctl, "wakeup");
 tctl->iswait = false;

 /* ====== user funtion begin ========== */
 if (tctl->exec_func != NULL) {
 tctl->exec_func(tctl, tctl->data);
 }
 /* ====== user funtion finish ========== */

 if (tctl->exit_func != NULL) {
 tctl->exit_func(tctl, tctl->data);
 }

 return NULL;
}

ThdCtl *create_thread(ProCtl *process, ThdHookFunc initfunc, ThdHookFunc execfunc, ThdHookFunc exitfunc, void *thddata)
{
 static int thdid = 0;

 ThdCtl *t = (ThdCtl *)malloc(sizeof(ThdCtl));
 if (t == NULL) {
 ASSERT(false);
 return NULL;
 }
 /* thread info */
 t->stat = -1;
 t->id = thdid++;

 /* thread function */
 t->init_func = initfunc;
 t->exec_func = execfunc;
 t->exit_func = exitfunc;
 t->data = thddata;
 t->stat = pthread_create(&t->thd, NULL, thread_main, t);

 /* thread control */
 t->iswait = true;
 sem_init(&t->wait, 0, 0);

 process->thdarr[process->thdnum] = t;
 process->thdnum++;

 return t;
}

ProCtl *create_process()
{
 ProCtl *pro = (ProCtl *)malloc(sizeof(ProCtl));
 ASSERT(pro != NULL);

 pro->thdnum = 0;
 memset(pro->thdarr, 0, sizeof(pro->thdarr));

 return pro;
}

void multi_execute(ThdHookFunc initfunc, ThdHookFunc execfunc, ThdHookFunc exitfunc, int thdnum, ThdData *dataarr)
{
 ProCtl *pro = create_process();

 LOG(NULL, "init ------------------------");
 int i;
 for (i = 0; i < thdnum; i++) {
 create_thread(pro, initfunc, execfunc, exitfunc, &dataarr[i]);
 }

 LOG(NULL, "execute ------------------------");
 for (i = 0; i < pro->thdnum; i++) {
 ThdCtl *tctl = pro->thdarr[i];
 sem_post(&tctl->wait);
 }

 for (i = 0; i < pro->thdnum; i++) {
 pthread_join(pro->thdarr[i]->thd, NULL);
 }
 LOG(NULL, "finish ------------------------");
}

2 多线程示例

fepaser

Wed, 21 May 2025 16:27:00 +0800

# 安装nodejs
yum install -y nodejs

# 安装claude
npm install -g @anthropic-ai/claude-code

# 验证
claude --version

cd /data/postgresql17

# 5. 启动 Claude Code 并进行首次认证
# 运行后，终端会提供一个链接，在浏览器中完成账号授权即可
claude

# 6. (可选但推荐) 生成项目记忆文件
# 在 Claude 交互界面中，输入以下命令，它会分析项目并生成 CLAUDE.md 文件
/init

数据库安全传输加密

Wed, 21 May 2025 09:37:00 +0800

非国密

生成证书
数据库服务端：配置证书、配置传输加密算法
数据库客户端：配置证书

# 检查openssl版本
which openssl
 # 确保使用的是vastbase发布包中的openssl，而非操作系统中的openssl

cp $GAUSSHOME/share/sslcert/gsql/openssl.cnf ./
export OPENSSL_CONF=`pwd`/openssl.cnf

# 创建文件
mkdir cert
cd cert
mkdir ./demoCA ./demoCA/newcerts ./demoCA/private
chmod 700 ./demoCA/private
echo '01'>./demoCA/serial
touch ./demoCA/index.txt

# ca
openssl genrsa -out ./demoCA/private/cakey.pem 2048
openssl req -new -key ./demoCA/private/cakey.pem -out ./demoCA/private/ca_cert_req.pem -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=root"
openssl x509 -req -in ./demoCA/private/ca_cert_req.pem -days 7300 -signkey ./demoCA/private/cakey.pem -out ./demoCA/cacert.pem

# server
openssl genrsa -out server.key 2048
openssl req -new -key server.key -out server.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=server"
openssl x509 -req -in server.csr -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -CAcreateserial -out server.crt

# client
openssl genrsa -out client.key 2048
openssl req -new -key client.key -out client.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=client"
openssl x509 -req -in client.csr -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -CAcreateserial -out client.crt

# 查看内容
openssl x509 -in client.crt -text

# 设置权限
chmod 600 client.key
chmod 600 client.crt
chmod 600 server.key
chmod 600 server.crt
chmod 600 ./demoCA/cacert.pem

export CERT=`pwd`
echo '
export CERT=`pwd`
export PGSSLMODE=verify-ca

export PGSSLROOTCERT=$CERT/demoCA/cacert.pem

export PGSSLKEY=$CERT/client.key
export PGSSLCERT=$CERT/client.crt
' > client_env

source client_env

# 设置服务端参数
gs_guc set -D $GAUSSHOME/data -c "ssl=on"
gs_guc set -D $GAUSSHOME/data -c "ssl_ciphers = 'ALL'"
gs_guc set -D $GAUSSHOME/data -c "ssl_ca_file = '$CERT/demoCA/cacert.pem'"
gs_guc set -D $GAUSSHOME/data -c "ssl_key_file='$CERT/server.key'"
gs_guc set -D $GAUSSHOME/data -c "ssl_cert_file='$CERT/server.crt'"

# 重启数据库

vsql -d postgres -c " CREATE USER u1 PASSWORD 'u1.password' "

# 连接数据库：需加-h参数
vsql -h localhost -d postgres -U u1 -W 'u1.password' -r

rm -f client.* server.*
gs_guc set -D $GAUSSHOME/data -c "ssl_ciphers = 'ECDHE-ECDSA-SM4-CBC-SM3'"

openssl ecparam -name SM2 -genkey -out ./demoCA/private/cakey.pem
openssl req -new -key ./demoCA/private/cakey.pem -out ./demoCA/private/ca_cert_req.pem -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=root"
openssl x509 -req -in ./demoCA/private/ca_cert_req.pem -days 7300 -signkey ./demoCA/private/cakey.pem -out ./demoCA/cacert.pem

# server
openssl ecparam -name SM2 -genkey -out server.key
openssl req -new -key server.key -out server.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=server"
openssl x509 -req -in server.csr -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -CAcreateserial -out server.crt

# client
openssl ecparam -name SM2 -genkey -out client.key
openssl req -new -key client.key -out client.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=client"
openssl x509 -req -in client.csr -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -CAcreateserial -out client.crt

chmod 600 client.key client.crt server.key server.crt ./demoCA/cacert.pem

openssl x509 -in client.crt -text

国密

mkdir cert
cd cert

openssl version
# OpenSSL 1.1.1s Tassl 2.1.2 1 Nov 2022

cp ../tassl/install/openssl.cnf ./
chmod +w ./openssl.cnf

echo '
[ gm_ca_cert ]
subjectKeyIdentifier=hash
authorityKeyIdentifier=keyid:always,issuer
basicConstraints = critical,CA:true
keyUsage = critical, cRLSign, keyCertSign

[ gm_sign_cert ]
basicConstraints = CA:FALSE
keyUsage = critical, digitalSignature, nonRepudiation

[ gm_enc_cert ]
basicConstraints = CA:FALSE
keyUsage = critical, keyEncipherment, dataEncipherment, keyAgreement' >> ./openssl.cnf

mkdir ./demoCA ./demoCA/newcerts ./demoCA/private
chmod 700 ./demoCA/private
echo '01'>./demoCA/serial
touch ./demoCA/index.txt

# ca
openssl ecparam -name SM2 -genkey -out ./demoCA/private/cakey.pem
openssl req -config openssl.cnf -new -key ./demoCA/private/cakey.pem -sm3 -out ./demoCA/private/ca_cert_req.pem -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=root"
openssl x509 -req -extfile openssl.cnf -extensions gm_ca_cert -in ./demoCA/private/ca_cert_req.pem -sm3 -days 7300 -signkey ./demoCA/private/cakey.pem -out ./demoCA/cacert.pem

# server
openssl ecparam -name SM2 -genkey -out server.key
openssl ec -in server.key -passout pass:gauss@123 -sm4 -out server.key
openssl req -config openssl.cnf -new -key server.key -passin pass:gauss@123 -sm3 -out server.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=server"
openssl x509 -req -extfile openssl.cnf -extensions gm_sign_cert -in server.csr -sm3 -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -passin pass:gauss@123 -CAcreateserial -out server.crt

# server.enc
openssl ecparam -name SM2 -genkey -out server_enc.key
openssl ec -in server_enc.key -passout pass:gauss@123 -sm4 -out server_enc.key
openssl req -config openssl.cnf -new -key server_enc.key -passin pass:gauss@123 -sm3 -out server_enc.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=server"
openssl x509 -req -extfile openssl.cnf -extensions gm_enc_cert -in server_enc.csr -sm3 -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -passin pass:gauss@123 -CAcreateserial -out server_enc.crt

gs_guc encrypt -M server -D ./ -K gauss@123

# client
openssl ecparam -name SM2 -genkey -out client.key
openssl ec -in client.key -passout pass:gauss@123 -sm4 -out client.key
openssl req -config openssl.cnf -new -key client.key -passin pass:gauss@123 -sm3 -out client.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=client"
openssl x509 -req -extfile openssl.cnf -extensions gm_sign_cert -in client.csr -sm3 -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -passin pass:gauss@123 -CAcreateserial -out client.crt

# client.enc
openssl ecparam -name SM2 -genkey -out client_enc.key
openssl ec -in client_enc.key -passout pass:gauss@123 -sm4 -out client_enc.key
openssl req -config openssl.cnf -new -key client_enc.key -passin pass:gauss@123 -sm3 -out client_enc.csr -subj "/C=CN/ST=Beijing/O=huawei/OU=gauss/CN=client"
openssl x509 -req -extfile openssl.cnf -extensions gm_enc_cert -in client_enc.csr -sm3 -days 3650 -CA ./demoCA/cacert.pem -CAkey ./demoCA/private/cakey.pem -passin pass:gauss@123 -CAcreateserial -out client_enc.crt

gs_guc encrypt -M client -D ./ -K gauss@123

# openssl x509 -in client.crt -text

export CERT=`pwd`
echo '
export CERT=`pwd`
export PGSSLMODE=verify-ca
export PGSSLTLCP=1

export PGSSLROOTCERT=$CERT/demoCA/cacert.pem

export PGSSLKEY=$CERT/client.key
export PGSSLCERT=$CERT/client.crt
export PGSSLENCKEY=$CERT/client_enc.key
export PGSSLENCCERT=$CERT/client_enc.crt
' > client_env

source client_env

# 设置服务端参数
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl=on"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_ciphers = 'ALL'"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_use_tlcp=on"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_ca_file = '$CERT/demoCA/cacert.pem'"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_key_file='$CERT/server.key'"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_cert_file='$CERT/server.crt'"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_enc_key_file='$CERT/server_enc.key'"
gs_guc set -D $GAUSSHOME/data/single_node -c "ssl_enc_cert_file='$CERT/server_enc.crt'"

# 重启数据库

数据库安全全密态

Tue, 20 May 2025 18:22:00 +0800

PQconnectStart
 makeEmptyPGconn
 connectOptions1
 parse_connection_string
 fillPGconn
 conninfo_getval("enable_ce") # 解析 'enable_ce'
 connectDBStart
 PQconnectPoll
 if CONNECTION_NEEDED: # 建立TCP连接
 connect
 elif CONNECTION_MADE: # 发送连接参数
 pqBuildStartupPacket3
 build_startup_packet
 pqPacketSend
 elif CONNECTION_AWAITING_RESPONSE # 进行身份认证
 pg_fe_sendauth
PQexec
 PQexecStart
 PQsendQuery
 Processor::run_pre_query # 加密SQL语句中的数据
 Parser::Parse
 run_pre_statement
 run_pre_insert_statement
 CachedColumnManager::get_cached_columns
 RawValues::get_raw_values_from_insert_statement
 ValuesProcessor::process_values
 process_inside_value # 加密
 StatementData::replace_raw_values
 pqPutMsgStart
 pqPuts
 pqPutMsgEnd
 pqFlush
 PQexecFinish
 PQgetResult
 parseInput
 pqParseInput3
 pqGetc
 pqGetInt
 case 'D'
 getAnotherTuple
 pqRowProcessor
 ValuesProcessor::deprocess_value # 解密服务端返回的数据
 pqGets
 case 'Z'
 Processor::run_post_query
 pqReadData

工具使用benchmarksql测试tpcc

Fri, 09 May 2025 11:41:00 +0800

2 安装数据库

scp shenkun@172.16.100.134:/home/shenkun/g100/pkg-5-19.tar.gz ./
vast@123

export GAUSSHOME=`pwd`
export PATH=$PATH:$GAUSSHOME/bin
export LD_

alias vinit='vb_initdb -D $GAUSSHOME/data -w vb.12345 --nodename=db1'
alias vstart='vb_ctl start -D $GAUSSHOME/data'
alias vrestart='vb_ctl restart -D $GAUSSHOME/data'

3 安装benchmarksql

一、下载benchmarksql

# 1.安装java openjdk
yum install java
yum install java-1.8.0-openjdk-devel
# 2.下载benchmark安装包
https://sourceforge.net/projects/benchmarksql/files/latest/download
# 3.下载ant安装包
https://dlcdn.apache.org//ant/binaries/apache-ant-1.10.15-bin.tar.gz
# 4.解压benchmark与ant安装包
 # 建议git初始化benchmark安装包，如果改错了可以回退

二、配置环境变量

# 1.生成环境变量脚本
touch envbm
# 在envbm中添加一下内容
export BMROOT=`pwd`
export BMCODE=$BMROOT/benchmarksql-5.0
export PATH=$PATH:$BMROOT/apache-ant-1.10.15/bin
export DBIP=127.0.0.1
export DBPORT=5432
# 2.配置环境变量
source envbm

三、配置benchmarksql配置文件

# 1.生成配置文件
mkdir cfg
cp $BMCODE/run/props.pg $BMROOT/cfg/props.pg
# 2.编辑配置文件
sed -i '/^user=/s/=.*/=u1/' f1
 # user=bmuser
 # password=bmuser@123

 # warehouses=10
 # loadWorkers=10

 # terminals=10
 # runMins=5
 # limitTxnsPerMin=0

# 3. 设置表的fillfictor=80
cp $BMCODE/run/sql.common/tableCreates.sql $BMCODE/run/sql.common/_tableCreates.sql

sed -i '/^);/s/);.*/) with (fillfactor=80);/' $BMCODE/run/sql.common/tableCreates.sql

四、生成便捷使用benchmarksql的脚本

数据库安全重构审计

Mon, 31 Mar 2025 19:24:00 +0800

1 审计的背景

1.1 审计的原理

在使用数据库存取数据的大部分场景中，数据库具有以下特点：

对象多：一个数据库集群中有多个database对象，1个database对象中有多个schema对象，1个schema对象中有多个table、index等对象
用户多：一个数据库中，有多个用户，每个用户可访问的数据库对象不同
应用多：多个应用将数据存储在同一数据库集群中，并同时访问数据库集群
操作多：数据库提供丰富的功能，包括DDL、DML、DCL、运维等
运行久：一个数据库集群，可能会保持数十年运行

审计的主要目的，使记录数据运行过程中发生了哪些事件。审计的3要素是：

主体：一般指数据库用户
客体：一般指数据库对象，包括：集群、数据对象（database、schema、table、index、function等）、用户等
操作：主体对客体的操作，比如某个用户访问了某个表

1.2 审计的目的

审计具有以下重要意义：

合法合规：《网络安全法》等法律法规与表中中，要求应用通过《等保测评》等标准，标准中要求应用具备审计功能
故障检测：当数据库出现故障时，协助快速定位问题
攻击检测：通过检查审计日志，可判断是否发生网络安全攻击事件
例行维护：通过检查审计日志，可跟踪对某个对象的访问信息
…

等保测评要求标准（GB/T 28448）中，对审计的要求如下：

审计范围
- 全面性
- 细粒度：登录、访问、修改、删除等
审计内容
- 用户行为：登录、登出、权限变更
- 数据访问：敏感数据查询、插入、更新、删除等
- 异常行为：登录失败、非法访问
审计记录
- 详细性：时间戳、用户标识、操作类型、操作结果、IP地址等
- 不可篡改：真实性、完整性
- 存储安全：未经授权的访问和修改
审计管理
- 审计策略：审计的目标、范围、内容和频率
- 审计分析：定期分析审计记录
- 审计报告

1.3 审计的功能

审计功能包含以下3个部分：

配置审计功能：日志存储策略等
设置审计范围：设置哪类操作、哪类对象、..需要给设计
生成审计日志：运行时，生成审计日志
管理审计日志：查询，删除，归档审计日志

1.4 oracle审计

oracle审计的发展：

oracle 8i及更早：支持传统审计
oracle 12c：新增支持统一审计
oracle 23ai：不支持传统审计，仅支持统一审计

oracle统一审计的使用：

-- 1 设置审计范围：创建审计策略
CREATE AUDIT POLICY ap1
 PRIVILEGES CREATE TABLE, ALTER USER -- privilege 子句，记录所有使用CreateTable, AlterUser权限的操作，oracle 12c中，支持256种权限
 ACTIONS SELECT,INSERT,UPDATE ON t1 -- aciton 子句，记录所有对表t1执行SELECT,INSERT,UPDATE的操作
 ROLES r1; -- role 子句，记录所有使用r1角色的操作

-- 2 启用审计策略
AUDIT POLICY ap1;

-- 3 查看审计日志（完整日志）
SELECT * FROM UNIFIED_AUDIT_TRAIL;

-- 查看关键日志
SELECT * FROM DBA_AUDIT_TRAIL; -- 其他：DBA_COMMON_AUDIT_TRAIL, DBA_AUDIT_SESSION, DBA_AUDIT_OBJECT, DBA_FGA_AUDIT_TRAIL

os_username | username | userhost | terminal | timestamp | owner | obj_name | action | action_name |
------------+----------+----------+----------+-----------+-------+----------+--------+-------------+

| new_owner | new_name | obj_privilege | sys_privilege | admin_option | grantee | audit_option | ses_actions |
+----------+----------+---------------+---------------+--------------+---------+--------------+-------------+

logoff_time | logoff_lread | logoff_pwrite | logoff_dlock | comment_text | sessionid | entryid | statementid | returncode |
+-----------+--------------+---------------+--------------+--------------+-----------+---------+-------------+------------+

| priv_used | client_id | econtext_id | session_cpu | extended_timestamp | proxy_sessionid | global_uid | instance_number |
+-----------+-----------+-------------+-------------+--------------------+-----------------+------------+-----------------+

os_process | transactionid | scn | sql_bind | sql_text | obj_edition_name | dbid | rls_info | current_user |
+----------+---------------+-----+----------+----------+------------------+------+----------+--------------+

其中，可设置的权限、操作等范围如下：

openGauss 升级

Thu, 06 Mar 2025 18:25:00 +0800

virtCCA

1 升级的流程

升级分类：
- 就地升级：暂停业务
- 灰度升级：不暂停业务，一次升级所有节点
- 节点升级：基于灰度升级，可升级部分节点

升级流程：（此处的命令是简化版命令，不能直接执行）

准备升级：检查安装包

开始升级：停止、启动集群，修改系统表

mkdir new_pkg
gs_preinstall -X config.xml
gs_upgradectl -t auto-upgrade -X config.xml --grey

验证升级

gsql -V
gaussdb -V
gsql -d postgres -p 5432 -c 'select working_version_num();' # 旧版本

提交升级

gs_upgradectl -t commit-upgrade -X config.xml --grey

回滚升级

gs_upgradectl -t auto-rollback -X config.xml

2 升级的原理

安装包

|-- install
 |-- share
 |-- postgresql
 |-- postgresql.conf.sample
 |-- postgres.bki
 |-- system_views.sql
 |-- extension
 |-- ...

main
 parseCommandLine
 checkParameter
 initGlobalInfos
 initClusterInfo
 UpgradeImplOLAP
 run
 Upgrade.run
 UpgradeImpl.run # UpgradeImpl.py
 initGlobalInfos
 commonCheck
 if 'auto_upgrade'
 doGreyBinaryUpgrade
 distributeXml
 checkUpgrade
 # 检查环境变量
 'Local_Check_Upgrade -t action -R oldapppath -l locallog -N newapppath -X config.xml'
 doHealthCheck
 checkClusterStatus
 checkConnection
 chooseUpgradeNodes
 prepareGreyUpgrade
 createBakPath
 'mkdir upgradeBackupPath'
 initNodeStepInCsv
 'touch upgrade_step.csv_bak'
 initUpgradeProcessStatus
 recordNodeStepInplace
 recordDirFile
 'touch record_app_directory'
 writeFile('oldClusterAppPath')
 copyBakVersion
 'cp oldapppath/bin/upgrade_version upgradeBackupPath/upgrade_version'
 installNewBin
 'Local_Install -t install_cluster -U user:group -R newapppath -P tmpdir -c clustername -l locallog -X config.cml -T -u'
 cpDolphinUpgradeScript
 'cp oldapppath/share/postgresql/extension/dolphin* newapppath/share/postgresql/extension/'
 prepareUpgradeSqlFolder # catalog upgrade_sql.tar.gz, including guc
 'Local_Upgrade_Utility -t prepare_upgrade_sql_folder -U user --upgrade_bak_path upgradeBackupPath -X config.xml -l locallog'
 updateCatalog
 'cp upgradeBackupPath/upgrade_sql/ {upgrade-post, upgrade, rollback-post, rollback}'
 doUpgradeCatalog
 setUpgradeFromParam
 'gs_guc set -Z cmagent -N all -I all -c upgrade_from=working_grand_version'
 reload_cm_proc
 setUpgradeMode(2)
 reloadCmAgent
 killKernalSnapshotThread
 execRollbackUpgradedCatalog('rollback')
 execRollbackUpgradedCatalog('upgrade')
 pgxcNodeUpdateLocalhost("upgrade")
 rebuild_pg_proc_proname_args_nsp_new_index
 upgradeAgain
 greySyncGuc
 'Local_Upgrade_Utility -t grey_sync_guc -U user --upgrade_bak_path=upgradeBackupPath -l logcallog'
 greySyncGuc # script/local/UpgradeUtility.py
 readDeleteGuc
 greySyncInstanceGuc
 greyUpgradeSyncOldConfigToNew
 'Local_Upgrade_Utility -t grey_upgrade_config_sync -U user -V oldversionnumber --old_cluster_app_path=oldapppath --new_cluster_app_path=newapppath -l locallog'
 greyUpgradeSyncConfig # 适配点, 参考 setUpradeModeGuc(

 getOneDNInst
 switchBin
 'Local_Upgrade_Utility -t switch_bin -U user -l localog -R new?oldapppath'
 restore_origin_disaster_user_file
 setNewVersionGuc
 switchExistsProcess
 _check_and_start_cluster
 'gs_om -t start'
 createCheckpoint
 switchDn
 waitClusterNormalDegrade
 doHealthCheck
 waitClusterForNormal
 backupGlobalRelmapFile
 printPrecommitBannervstart
 elif 'commit':
 doGreyCommitUpgrade

参考

opengauss om源码：https://gitee.com/opengauss/openGauss-OM
opengauss升级：https://docs.opengauss.org/zh/docs/latest/docs/DatabaseOMGuide/upgrade.html

openGauss 身份认证 GUC参数

Fri, 28 Feb 2025 16:43:00 +0800

1 身份认证

身份认证
大部分数据库都支持基于口令的身份认证，以vastbase为例，身份认证的流程如下：

高权限用户创建新用户
```
CREATE USER u1 PASSWORD 'u1.pass1';
```

数据库在pg_authid系统表中存储用户以及密码的哈希

SELECT oid, rolname, rolvalidbegin, rolpassword FROM pg_authid WHERE rolname = 'u1';

 oid | rolname | rolvalidbegin | rolpassword
 -------+---------+---------------+--------------------------------------------------------------------------
 24576 | u1 | | sha2565e3b533ca5db32acdffdb6aea03395af163ac3cfdc9ddb.......

数据库在pg_auth_history系统表中存储密码创建时间

SELECT roloid, passwordtime FROM pg_auth_history;

 oid | passwordtime
 -------+-------------------------------
 24576 | 2025-02-11 12:17:02.969642+08

新用户登录数据库

gsql -d postgres -U u1 -W 'u1.pass1' -r

数据库校验新用户信息：数据库接收用户建立连接的请求时，会进行一系列身份鉴别操作，包括：检查用户提供的密码与pg_authid中的值是否匹配，检查pg_auth_history中记录的密码生成日期与当前日期是否间隔较久等

mysql 1 安装mysql

Mon, 24 Feb 2025 11:24:00 +0800

1 安装mysql

# root
yum -y install wget cmake gcc gcc-c++ ncurses ncurses-devel libaio-devel openssl openssl-devel
yum -y install cmake3

# 普通用户
cd ~
mkdir mysql && cd mysql
wget https://dev.mysql.com/get/Downloads/MySQL-8.0/mysql-boost-8.0.17.tar.gz
tar -zxvf mysql-boost-8.0.17.tar.gz
mkdir backup && mv *.tar.gz backup

mkdir install data boost
cd mysql-boost*

cmake3 . -DCMAKE_INSTALL_PREFIX=`pwd`/../install -DMYSQL_DATADIR=`pwd`/../data -DSYSCONFDIR=`pwd`/../data -DMYSQL_TCP_PORT=3306 -DWITH_BOOST=`pwd`/../boost \
-DDEFAULT_CHARSET=utf8 -DDEFAULT_COLLATION=utf8_general_ci -DENABLED_LOCAL_INFILE=ON -DWITH_INNODB_MEMCACHED=ON -DWITH_INNOBASE_STORAGE_ENGINE=1 -DWITH_FEDERATED_STORAGE_ENGINE=1 -DWITH_BLACKHOLE_STORAGE_ENGINE=1 -DWITH_ARCHIVE_STORAGE_ENGINE=1 -DWITHOUT_EXAMPLE_STORAGE_ENGINE=1 -DWITH_PERFSCHEMA_STORAGE_ENGINE=1

openGauss 1 安装openGauss

Thu, 20 Feb 2025 14:06:00 +0800

1 安装wsl

请自行在网上了解wsl是什么，以及如何在wsl中安装centos 7：

在windows 11中，启用wsl
下载centos 7的wsl 安装包
在wsl中，安装centos 7
进入centos 7，创建普通用户，建议使用mobaxterm直接登录wsl中的centos系统
配置centos 7的yum源

2 准备环境

下载opengauss源码

git clone -b master git@gitee.com:opengauss/openGauss-server.git

下载第三方库

wget https://opengauss.obs.cn-south-1.myhuaweicloud.com/latest/binarylibs/gcc10.3/openGauss-third_party_binarylibs_Centos7.6_x86_64.tar.gz

解压第三方库

# 解压压缩包
tar -zxvf openGauss-third*

# 归档压缩包
mkdir tmp
mv *.tar.gz tmp

# 重命名压缩包
mv openGauss-third* third

下载依赖库

yum install -y libaio-devel flex bison ncurses-devel patch readline-devel

# 单独安装 glibc-devel
yum install glibc-devel
# 如果报错，提示安装了.i686版本的glibc-devel，则修改yum配置文件：
# echo "exclude=*.i686" >> /etc/yum.conf

# 如果报错，提示glibc-devel与glibc-common不匹配，则降级glibc和glibc-common
# yum downgrade glibc glibc-devel glibc-common glibc-headers
# 降级后，再重新安装 glibc-devel 即可
# yum install glibc-devel

Oracle 1 SQL

Thu, 20 Feb 2025 14:06:00 +0800

1 Oracle 集群管理

1.2 登录数据库

sqlplus / as sysdba

2 Oracle 语法

2.1 数据类型

仅列举常见数据类型：

大类	类型	解释
数值	INT or INTGER	整数
-	NUMBESR(p, s)	p: 精度，整数和小数总位数，s: 小数位数
-	SMALLINT	等于 NUMBESR(38)
-	FLOAT(p)	浮点数，p: 二进制精度，最大126
字符	CHAR(n)	固定长度字符，n: 长度，不足n用空格填充
-	VARCHAR2(n)	可变长度字符，n: 最大长度，最大4000
时间	DATE	日期
-	TIMESTAMP	日期和时间
二进制	CLOB	长文本数据

2.2 常用SQL

常见语法

-- 1 创建表
CREATE TABLE t1 (c1 INT, c2 VARCHAR2(10));

-- 2 插入数据
INSERT INTO t1 VALUES (1, 'abcc');
INSERT INTO t1 VALUES (2, 'ddee');

-- 3 查询数据
SELECT * FROM t1 WHERE c1 > 0;

-- 4 更新数据
UPDATE t1 SET c2 = 'abbc' WHERE c1 = 1;

-- 5 删除数据
DELETE FROM t1 WHERE c1 = 2;

-- 6 删除表
DROP TABLE t1;

内置函数

Vastbase

Thu, 20 Feb 2025 14:06:00 +0800

1 准备开发环境

1.1 登录远程windows

连接vpn
下载vpn软件，使用入职时他人帮忙申请的vpn账号登录
登录远程windows电脑
使用入职时他人帮忙申请的远程windows账号
登录gitlab
入职时，有人已帮忙申请gutlab账号。http://172.16.19.246
查看vastbase代码
http://172.16.19.246/VastbaseG100/src
- 默认无权限，可能搜不到，请找小组领导开通权限

1.2 准备vastbase编译环境

在远程windows中，登录远程centos

配置git
生成rsa密钥，配置到gitlab中

下载vastbase源码

mkdir g100
cd g100
git clone -b master git@172.16.19.246:VastbaseG100/src.git

下载vastbase依赖的二进制文件
需要自行通过svn下载，然后，上传到vastbase源码同级目录
- ip: 172.16.19.4
- 用户名: clouder
- 密码: 自行询问
- 目录: /Database/Vastbase/third_party

配置用于编译vastbase的环境变量

cd g100
touch venv

请确保此时的目录结构如下：

ls g100

|-- g100
 |-- src
 |-- binarylibs
 |-- venv

设置环境变量，在venv文件中，输入以下内容：

export CODE_BASE=`pwd`
export BINARYLIBS=`pwd`/binarylibs
# 安装目录在源码里写死了，改不了
export GAUSSHOME=`pwd`/src/mppdb_temp_install
export GCC_PATH=$BINARYLIBS/buildtools/gcc7.3
export CC=$GCC_PATH/gcc/bin/gcc
export CXX=$GCC_PATH/gcc/bin/g++

export LD_LIBRARY_PATH=$GAUSSHOME/lib:$GCC_PATH/gcc/lib64:$GCC_PATH/isl/lib:$GCC_PATH/mpc/lib/:$GCC_PATH/mpfr/lib/:$GCC_PATH/gmp/lib/:$LD_LIBRARY_PATH
export PATH=$GAUSSHOME/bin:$GCC_PATH/gcc/bin:$PATH

# 以下是vastbase增加的
export PATH=$BINARYLIBS/buildtools/cmake/bin:$PATH

配置快捷命令

vastbase 身份认证

Mon, 17 Feb 2025 14:43:00 +0800

国策用例


4、配置客户端认证方式
hostssl all all 0.0.0.0/0 cert

1、生成国密证书
创建 CA 目录 cadir 并进入
mkdir cadir
cd cadir
copy 配置文件 openssl.cnf 到当前目录（不同环境，配置文件路径可能不一样）
cp /etc/pki/tls/openssl.cnf .
开始搭建CA环境
mkdir ./demoCA ./demoCA/newcerts ./demoCA/private
chmod 777 ./demoCA/private
创建serial文件,写入01
echo '01'>./demoCA/serial
创建文件index.txt
touch ./demoCA/index.txt
修改openssl.cnf配置文件中CA_default的参数
dir = ./demoCA
default_md = sha256
至此CA环境搭建完成
生成CA私钥
openssl ecparam -out demoCA/private/cakey.pem -name SM2 -genkey
生成根证书请求文件
openssl req -config openssl.cnf -key demoCA/private/cakey.pem -new -out cacert.req -subj /C=CN/ST=BJ/L=HaiDian/O=VAST/OU=SEC/CN=CLIENT
生成自签发根证书
生成根证书时，需要修改openssl.cnf文件，设置basicConstraints=CA:TRUE
vi openssl.cnf
生成CA自签发根证书
openssl ca -config openssl.cnf -in cacert.req -keyfile demoCA/private/cakey.pem -selfsign -out demoCA/cacert.pem
生成服务器私钥文件server.key
openssl ecparam -out server.key -name SM2 -genkey
生成服务器证书请求文件server.req
openssl req -config openssl.cnf -key server.key -new -out server.req -subj /C=CN/ST=BJ/L=HaiDian/O=VAST/OU=SEC/CN=server
生成服务端/客户端证书时，修改openssl.cnf文件，设置basicConstraints=CA:FALSE
vi openssl.cnf
对生成的服务器证书请求文件进行签发，签发后将生成正式的服务器证书server.crt
openssl ca -config openssl.cnf -in server.req -out server.crt -days 3650
生成客户端私钥
openssl ecparam -out client.key -name SM2 -genkey
生成客户端证书请求文件
openssl req -config openssl.cnf -new -key client.key -out client.req -subj /C=CN/ST=BJ/L=HaiDian/O=VAST/OU=SEC/CN=client
对生成的客户端证书请求文件进行签发，签发后将生成正式的客户端证书client.crt
openssl ca -config openssl.cnf -in client.req -out client.crt -days 3650

注：中间会产生交互，按照以下内容进行填写（需注意每个交互的common name填不一样的内容，如分别写：test1,test2,test3）：
Country Name (2 letter code) [AU]:CN
State or Province Name (full name) [Some-State]:shanxi
Locality Name (eg, city) []:xian
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Abc
Organizational Unit Name (eg, section) []:hello
--Common Name可以随意命名
Common Name (eg, YOUR name) []:world
--Email可以选择性填写
Email Address []:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []: 1qaz!QAZ
An optional company name []:world

# ---------------------------------------
https://gitee.com/opengauss/openGauss-server/pulls/3254

mkdir certs
cp ../../tassl/tassl_demo/cert/openssl.cnf certs/
cd certs
#CA
openssl ecparam -genkey -name SM2 -out CA.key
openssl req -config openssl.cnf -new -subj /C=CN/ST=BJ/L=HaiDian/O=YUNHEENMO/OU=MogDB/CN=FooCA -key CA.key -out CA.csr
openssl x509 -sm3 -req -days 1500 -in CA.csr -extfile openssl.cnf -extensions v3_ca -signkey CA.key -out CA.crt

#server
openssl ecparam -genkey -name SM2 -out server.key
openssl req -config openssl.cnf -new -subj /C=CN/ST=BJ/L=HaiDian/O=YUNHEENMO/OU=MogDB/CN=server -key server.key -out server.csr
openssl x509 -sm3 -req -days 1500 -in server.csr -CA CA.crt -CAkey CA.key -extfile openssl.cnf -out server.crt -CAcreateserial

#server_enc
openssl ecparam -genkey -name SM2 -out server_enc.key
openssl req -config openssl.cnf -new -subj /C=CN/ST=BJ/L=HaiDian/O=YUNHEENMO/OU=MogDB/CN=server -key server_enc.key -out server_enc.csr
openssl x509 -sm3 -req -days 1500 -in server_enc.csr -CA CA.crt -CAkey CA.key -extfile openssl.cnf -out server_enc.crt -CAcreateserial

#client
openssl ecparam -genkey -name SM2 -out client.key
openssl req -config openssl.cnf -new -subj /C=CN/ST=BJ/L=HaiDian/O=YUNHEENMO/OU=MogDB/CN=client -key client.key -out client.csr
openssl x509 -sm3 -req -days 1500 -in client.csr -CA CA.crt -CAkey CA.key -extfile openssl.cnf -out client.crt -CAcreateserial

#client_enc
openssl ecparam -genkey -name SM2 -out client_enc.key
openssl req -config openssl.cnf -new -subj /C=CN/ST=BJ/L=HaiDian/O=YUNHEENMO/OU=MogDB/CN=client -key client_enc.key -out client_enc.csr
openssl x509 -sm3 -req -days 1500 -in client_enc.csr -CA CA.crt -CAkey CA.key -extfile openssl.cnf -out client_enc.crt -CAcreateserial

#修改权限
chmod 0600 *

#增加密码保护

openssl ec -sm4 -in server.key -out server.key -passout pass:123qweQWE
gs_guc generate -S 123qweQWE -D ./ -o server
openssl ec -sm4 -in server_enc.key -out server_enc.key -passout pass:234werWER
gs_guc generate -S 234werWER -D ./ -o server_enc
openssl ec -sm4 -in client.key -out client.key -passout pass:345ertERT
gs_guc generate -S 345ertERT -D ./ -o client
openssl ec -sm4 -in client_enc.key -out client_enc.key -passout pass:456rtyRTY
gs_guc generate -S 456rtyRTY -D ./ -o client_enc
chmod 0600 *

#客户端：
export CERT=`pwd`
echo '
export CERT=`pwd`
export PGSSLMODE=verify-ca
export PGSSLTLCP=1

export PGSSLROOTCERT=$CERT/CA.crt

export PGSSLKEY=$CERT/client.key
export PGSSLCERT=$CERT/client.crt
export PGSSLENCKEY=$CERT/client_enc.key
export PGSSLENCCERT=$CERT/client_enc.crt
' > client_env

source client_env

#服务器：

gs_guc set -D $GAUSSHOME/data -c "ssl=on"
gs_guc set -D $GAUSSHOME/data -c "ssl_ciphers = 'ALL'"
gs_guc set -D $GAUSSHOME/data -c "ssl_use_tlcp=on"
gs_guc set -D $GAUSSHOME/data -c "ssl_ca_file = '$CERT/CA.crt'"
gs_guc set -D $GAUSSHOME/data -c "ssl_key_file='$CERT/server.key'"
gs_guc set -D $GAUSSHOME/data -c "ssl_cert_file='$CERT/server.crt'"
gs_guc set -D $GAUSSHOME/data -c "ssl_enc_key_file='$CERT/server_enc.key'"
gs_guc set -D $GAUSSHOME/data -c "ssl_enc_cert_file='$CERT/server_enc.crt'"

1、生成国密证书
# 创建 CA 目录 cadir 并进入

# copy 配置文件 openssl.cnf 到当前目录（不同环境，配置文件路径可能不一样）
cp /etc/pki/tls/openssl.cnf .
# 开始搭建CA环境
mkdir ./demoCA ./demoCA/newcerts ./demoCA/private
chmod 777 ./demoCA/private
# 创建serial文件,写入01
echo '01'>./demoCA/serial
# 创建文件index.txt
touch ./demoCA/index.txt

# 至此CA环境搭建完成
# 生成CA私钥
openssl ecparam -out demoCA/private/cakey.pem -name SM2 -genkey
# 生成根证书请求文件
openssl req -config openssl.cnf -key demoCA/private/cakey.pem -new -out cacert.req
# 生成自签发根证书
# 生成根证书时，需要修改openssl.cnf文件，设置basicConstraints=CA:TRUE
vi openssl.cnf
# 生成CA自签发根证书
openssl ca -config openssl.cnf -in cacert.req -keyfile demoCA/private/cakey.pem -selfsign -out demoCA/cacert.pem

# 生成服务器私钥文件server.key
openssl ecparam -out server.key -name SM2 -genkey
# 生成服务器证书请求文件server.req
openssl req -config openssl.cnf -key server.key -new -out server.req
# 生成服务端/客户端证书时，修改openssl.cnf文件，设置basicConstraints=CA:FALSE
vi openssl.cnf
# 对生成的服务器证书请求文件进行签发，签发后将生成正式的服务器证书server.crt
openssl ca -config openssl.cnf -in server.req -out server.crt -days 3650

# 生成客户端私钥
openssl ecparam -out client.key -name SM2 -genkey
# 生成客户端证书请求文件
openssl req -config openssl.cnf -new -key client.key -out client.req
# 对生成的客户端证书请求文件进行签发，签发后将生成正式的客户端证书client.crt
openssl ca -config openssl.cnf -in client.req -out client.crt -days 3650

# 注：中间会产生交互，按照以下内容进行填写（需注意每个交互的common name填不一样的内容，如分别写：test1,test2,test3）：
Country Name (2 letter code) [AU]:CN
State or Province Name (full name) [Some-State]:shanxi
Locality Name (eg, city) []:xian
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Abc
Organizational Unit Name (eg, section) []:hello
--Common Name可以随意命名
Common Name (eg, YOUR name) []:world
--Email可以选择性填写
Email Address []:

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []: 1qaz!QAZ
An optional company name []:world

2、配置客户端文件
chmod 600 client.key
chmod 600 client.crt
chmod 600 ./demoCA/cacert.pem
chmod 600 server.key
chmod 600 server.crt

3、配置服务器端参数
cp server.crt server.key ./demoCA/cacert.pem $PGDATA
cp client.crt client.key /home/vastbase/data/vastbase/

export PGSSLCERT="/home/vastbase/cadir/client.crt"
export PGSSLKEY="/home/vastbase/cadir/client.key"
export PGSSLMODE="verify-ca"
export PGSSLROOTCERT="/home/vastbase/data/vastbase/cacert.pem"

vi postgresql.conf
ssl = on
require_ssl = on
ssl_cert_file = 'server.crt'
ssl_key_file = 'server.key'
ssl_ca_file = 'cacert.pem'
ssl_crl_file = ''

4、配置客户端认证方式
vi pg_hba.conf
hostssl all all 0.0.0.0/0 cert

5、重启数据库服务
vb_ctl restart
vsql - vastbase -r
--创建生成客户端证书时Common Name同名用户
create user test3 password'Test@123';

1、客户端vsql连接到服务端
vsql -dvastbase -r -h IP -U test3

--预期
连接成功，提示SSL connection

1 需求背景

1.2 Oracle Profile功能

一、查看profile信息

设置sqlplus输出格式

vastbase 加密函数

Sun, 09 Feb 2025 16:10:00 +0800

1 需求背景

1.1 数据加密背景

加密的原理
不同场景中，适合的加密算法类型不同。对存储数据加密，通常采用对称密码算法，此处主要介绍对称密码算法：
- 加密原理：输入1个明文，输入1个密钥，对明文和密钥进行一些运算（比如异或，代换），可得到1个密文。密钥通常是随机生成的。
- 加密算法：DES算法，发布于1977年，已确定为不安全加密算法。3DES算法，调用3次DES算法，生成3个密钥，安全性与DES差别不大，也属于不安全的加密算法。AES算法，发布于2001年，通用的国际标准

数据库加密函数
几乎所有数据库，都提供内置加密函数，让用户通过SQL语句调用。最典型的场景如下：

-- 假设，数据库提供函数encrypt(明文，密钥，加密算法)，输出为密文
-- 用户想表't1'中存储数据'shenkun'，则存储的语法如下：（用户自己保管密钥）
INSERT INTO t1 VALUES (encrypt('shenkun', '一串随机的密钥', 'aes'));

1.2 oracle 加密包

早期版本的oracle中，包含1个名为dbms_obfuscation_toolkit的包，提供7个函数，主要实现加密、解密等功能：

版本信息：oracle 8i版本开始提供，oracle 10g版本开始不被推荐使用，由dbms_crypto代替，oracle 21c版本正式移除
函数列表：
- 生成随机数：desgetkey(seed) -> key
- 加密：desencrypt(input, key) -> encrypted_data
- 解密：descdecrypt(input, key) -> decrypted_data
- 生成随机数：des3getkey(which=>0, seed) -> key
- 加密：des3encrypt(input, key, which=>0, iv=>012345678abcdef) -> encrypted_data
- 解密：des3decrypt(input, key, which=>0, iv=>012345678abcdef) -> decrypted_data
- 哈希：md5(input) -> checksum
函数参数：函数参数有3种数据类型：varchar2, raw。与raw类型相比，如果是varchar2类型，参数名需加上_string后缀。比如，raw类型的入参名为input，则varcha2类型入参名为input_string
函数限制：
- desgetkey：seed长度最短为80字节
- desencrypt：input长度是8字节的整数倍；key最短为8字节，超过8字节的部分被丢弃
- descdecrypt：input长度是8字节的整数倍；key最短为8字节，超过8字节的部分被丢弃
- des3getkey: seed长度最短为80字节
- des3encrypt：input长度是8字节的整数倍；which为0时，key最短为16字节，超过16字节的部分被丢弃；which为1时，key最短为24字节，超过24字节的部分被丢弃
- des3dencrypt：input长度是8字节的整数倍；which为0时，key最短为16字节，超过16字节的部分被丢弃；which为1时，key最短为24字节，超过24字节的部分被丢弃
- md5：无
参考文档
- 函数介绍：函数背景、注意事项等：https://docs.oracle.com/cd/A97630_01/appdev.920/a96590/adgsec04.htm
- 函数参数：参数类型、调用示例等：https://docs.oracle.com/cd/B10500_01/appdev.920/a96612/d_obtoo2.htm

以下是上述函数的调用示例：

Vastbase 搭建环境、编译代码、安装数据库

Sat, 08 Feb 2025 16:44:00 +0800

1 准备开发环境

1.1 登录远程windows

连接vpn
下载vpn软件，使用入职时他人帮忙申请的vpn账号登录
登录远程windows电脑
使用入职时他人帮忙申请的远程windows账号
登录gitlab
入职时，有人已帮忙申请gutlab账号。http://172.16.19.246
查看vastbase代码
http://172.16.19.246/VastbaseG100/src
- 默认无权限，可能搜不到，请找小组领导开通权限

1.2 准备vastbase编译环境

在远程windows中，登录远程centos

配置git
生成rsa密钥，配置到gitlab中

下载vastbase源码

mkdir g100
cd g100
git clone -b master git@172.16.19.246:VastbaseG100/src.git

下载vastbase依赖的二进制文件
需要自行通过svn下载，然后，上传到vastbase源码同级目录
在文件管理器中，输出ftp://172.16.19.4后，会提示输出账号和密码
- ip: 172.16.19.4
- 用户名: clouder
- 密码: 自行询问
- 目录: /Database/Vastbase/third_party

配置用于编译vastbase的环境变量

cd g100
touch venv

请确保此时的目录结构如下：

ls g100

|-- g100
 |-- src
 |-- binarylibs
 |-- venv

设置环境变量

export CODE_BASE=`pwd`
export BINARYLIBS=`pwd`/binarylibs
# 安装目录在源码里写死了，改不了
export GAUSSHOME=`pwd`/src/mppdb_temp_install
export GCC_PATH=$BINARYLIBS/buildtools/gcc7.3
export CC=$GCC_PATH/gcc/bin/gcc
export CXX=$GCC_PATH/gcc/bin/g++

export LD_LIBRARY_PATH=$GAUSSHOME/lib:$GCC_PATH/gcc/lib64:$GCC_PATH/isl/lib:$GCC_PATH/mpc/lib/:$GCC_PATH/mpfr/lib/:$GCC_PATH/gmp/lib/:$LD_LIBRARY_PATH
export PATH=$GAUSSHOME/bin:$GCC_PATH/gcc/bin:$PATH

# 以下是vastbase增加的
export PATH=$BINARYLIBS/buildtools/cmake/bin:$PATH

配置快捷命令

Oracle 安全特性

Fri, 07 Feb 2025 11:55:00 +0800

1 概述

来源：https://docs.oracle.com/en/database/oracle/oracle-database/23/dbseg
基础安全
- 身份认证
  - 密码最小长度
  - 连续失败锁定
  - 账户锁定
  - 新旧密码重复
  - 密码有效期
- 访问控制
- 敏感数据发现
- 传输加密
- 安全审计
高级安全
- 透明加密
- 数据脱敏
- 访问控制
  - 行级访问控制
  - 数据库保险柜：细粒度访问控制

Oracle 基本介绍

Sat, 25 Jan 2025 11:24:00 +0800

1 Oracle 集群管理

1.2 登录数据库

sqlplus / as sysdba

2 Oracle 语法

2.1 数据类型

仅列举常见数据类型：

大类	类型	解释
数值	INT or INTGER	整数
-	NUMBESR(p, s)	p: 精度，整数和小数总位数，s: 小数位数
-	SMALLINT	等于 NUMBESR(38)
-	FLOAT(p)	浮点数，p: 二进制精度，最大126
字符	CHAR(n)	固定长度字符，n: 长度，不足n用空格填充
-	VARCHAR2(n)	可变长度字符，n: 最大长度，最大4000
时间	DATE	日期
-	TIMESTAMP	日期和时间
二进制	CLOB	长文本数据

2.2 常用SQL

常见语法

-- 1 创建表
CREATE TABLE t1 (c1 INT, c2 VARCHAR2(10));

-- 2 插入数据
INSERT INTO t1 VALUES (1, 'abcc');
INSERT INTO t1 VALUES (2, 'ddee');

-- 3 查询数据
SELECT * FROM t1 WHERE c1 > 0;

-- 4 更新数据
UPDATE t1 SET c2 = 'abbc' WHERE c1 = 1;

-- 5 删除数据
DELETE FROM t1 WHERE c1 = 2;

-- 6 删除表
DROP TABLE t1;

内置函数

工具配置新环境

Fri, 24 Jan 2025 16:14:00 +0800

设置bash

export PS1="[\e[35;1m][\$(date +'%m-%d/%H:%M:%S')][\e[36;1m]\w [\e[0m]\n> "

安装code-servels

https://blog.zhaokeyong.cn/archives/CentOScode-server
安装3.4版本，方便

# 1 从本地机器上，找到code-server所在文件夹
cd /home/shenkun/vscode
mkdir allpkg
# 放插件的目录
cp -r ~/.local allpkg
cp -r ./code-server allpkg
tar -zcvf allpkg.tar.gz allpkg

cd /home/shenkun/vscode
tar -zxvf allpkg.tar.gz
mv allpkg/code-server ./
rm -rf ~/.local/share/code-server/*
mv allpkg/.local/share/code-server/* ~/.local/share/code-server

nohup ./code-server &

# 设置配置文件
vi ~/.config/code-server/config.yaml
bind-addr: 0.0.0.0:3000
auth: password
password: password
cert: false

nohup ./code-server &

常用插件：

c/c++
gitlens
markdown preview enhanced

安装 oracle

kkdb 1 预览

Tue, 21 Jan 2025 13:55:00 +0800

1 基本介绍

要求

数据库基本原理
C语言
数据结构
操作系统

数据存储需求

数据存储方案

文件
excel
数据库

2 kkdb

成果展示

初始化

# 系统表
sys_class: 存储所有表
sys_attr: 存储所有列

dbinit
ls ~/dbdata

基本语法

CREATE

输入：CREATE TABLE t1 (c1 INT, c2 TEXT);
语法解析：表名、列名、列数据类型
系统表：存储表信息、列信息
表文件：创建文件

INSERT

输入：INSERT INTO t1 VALUES (1, 'first')
语法解析：表名、列数据
数据处理：封装数据
表文件：写入数据

SELECT

输入：SELECT * FROM t1
语法解析：表名、列
表文件：读取数据
数据处理：解析数据

UPDATE
DELETE
DROP

并发访问

CS模式

服务器
```
dbserver start
```

客户端

dbclient 127.0.0.1 8888
SELECT * FROM t1;

服务器多线程

tool.flex.词法解析工具

Tue, 21 Jan 2025 13:55:00 +0800

1 概述
2 flex
参考：

1 概述

需求
判断字符串，是否满足规定的规则。

示例
字符串：

‘abc’, ‘a1’, ‘a+’, …

规则：

字符串中只包含字母

编码：

/* 省略 */

问题：

复杂性：在字符串较长，规则繁多时，判断逻辑将会很复杂，编码工作量大

方案：

通过通用的正则表达式制定规则

通过很多开源或非开源的词法解析工具，实现判断逻辑。

正则表达式：

[a-zA-Z]+ ：字符串中只包含字母

如此，我们仅需简单制定正则表达式，通过第三方词法解析工具实现判断逻辑。

2 flex

1 词法解析
词法解析工具有很多，本文仅介绍flex。
flex编写的规则文件，后缀为.l

2 编译流程

编写 [规则.l] 文件

通过flex，将 [规则.l] 文件，转换为 [规则.c] 文件

将 [规则.c] 文件，以其他文件一起，正常编译即可

3 文件格式

%{
/* include */
%}

/* define */

%%
rule {code();}
%%

void usercode()
{
 yylex();
}

4 正则表达式
单字符

tool.markdown.轻量级语言语法

Tue, 21 Jan 2025 13:55:00 +0800

说明：原始markdow语法见本文底部

标题：1
1. 标题：1.1
  1. 标题：1.1.1
    1. 标题：1.1.1.1
      1. 标题：1.1.1.1.1
        
        标题：1.1.1.1.1.1

加粗：test
横线：~~test~~
斜体：test

标题：1

标题：1.1

标题：1.1.1

标题：1.1.1.1

标题：1.1.1.1.1

标题：1.1.1.1.1.1

$~~$缩进

节点：

a
b
- ba

序号：

a
b
1. c
2. d

分割线

链接：点我

链接：[id]
something
something

图片：[![desc](/path/to/img.png)](http://www.baidu.com/ "desc")

引用：

line 1
line 2

ada

代码func(int a, int b)

代码块：

def func(int a, int b)
{
 return 0;
}

def func(a, b):
 c = "abc"
 return a + b

表格：

c1	c2	c3
1	2	3
2	2	3

html转换：
♥

分页符：

[========]

abc

目录：
 标题：1标题：1.1标题：1.1.1标题：1.1.1.1标题：1.1.1.1.1标题：1.1.1.1.1.1

加粗：**test**
横线：~~test~~
斜体：*test*

# 标题：1
## 标题：1.1
### 标题：1.1.1
#### 标题：1.1.1.1
##### 标题：1.1.1.1.1
###### 标题：1.1.1.1.1.1

$~~$

节点：
- a
- b
 - ba

序号：
1. a
2. b
 1. c
 2. d

分割线

------------

链接：[点我](http://www.baidu.com "点我")

链接：[[id]][linkid]
something
something

[linkid]: http://www.baidu.com

图片：
[![desc](../../1.PNG)](http://www.baidu.com "desc")

引用：
> line 1
> line 2

ada

代码`func(int a, int b)`

代码块：

def func(int a, int b)
{
 return 0;
}

def func(a, b):
 c = "abc"
 return a + b

表格：
| c1 | c2 | c3 |
| :- | -: | :-: |
| 1 | 2 | 3|
| 2 | 2 |3|

html转换：
&hearts;

分页符：

[========]

abc

tool.webssh.网页版SSH工具

Tue, 21 Jan 2025 13:55:00 +0800

感谢
开源项目：https://gitee.com/careyjike_173/webssh

tool.yacc.语法解析工具

Tue, 21 Jan 2025 13:55:00 +0800

1 概述

1 概述

需求
判断语法是否正确

操作系统 1 总结

Tue, 21 Jan 2025 13:55:00 +0800

1 CPU结构

1.1 CPU结构

1.2 CPU寻址

5种寻址方式
- 直接寻址 : [1]
- 寄存器间接寻址 [bx]
- 寄存器相对寻址 [bx + 1]
- 基址变址寻址 [bx + si]
- 相对基址变址寻址 [bx + si + 1]

2 内存管理

2.1 内存申请

libc内部free list
libc申请新逻辑页
- 内核使用伙伴算法，分配物理页，插入页表

操作系统 2 原理

Tue, 21 Jan 2025 13:55:00 +0800

0 架构

0.1 OS功能

从资源管理角度划分：

进程/线程管理
内存管理
文件管理
设备管理
用户接口

0.2 OS特征

并发
共享
虚拟
随机：不可预测的事件，状态随机

0.3 OS结构

整体架构：

计算机网络 1 总结

Tue, 21 Jan 2025 13:55:00 +0800

整体架构
物理层
链路层
传输层
应用层
socket编程
目录
0 概述
1. 0.1 七层体系结构
2. 0.2 报文基本原理
1 应用层
1. 1.1 HTTP协议
  1. 1.1.1 HTTP 结构
  2. 1.1.2 HTTP 应用
2. 1.2 DNS 协议
2 传输层
1. 2.1 TCP
  1. 2.1.1 TCP 的结构
  2. 2.1.2 TCP 的应用
3 网络层
1. 3.1 IP
  1. 3.1 IP 协议
  2. 3.1.2 IP 路由
2. 3.2 ICMP
4 链路层
5 物理层
6 socket编程

0 概述

0.1 七层体系结构

计算机网络使用自顶向下的多层网络结构：

海量 10 设计 SSL协议

Tue, 09 Sep 2025 18:48:00 +0800

1 TLS协议支持第三方流量审计

1.1 功能简述

【需求背景】
TLS协议，是保障通信安全的加密协议，可分为4个子功能：

密钥生成：通过密钥交换或密钥协商等协议，让双方生成相同的密钥
身份认证：在开始阶段，双方均向对方发送自己的证书。双方接收证书后，基于PKI体系，校验证书是否合法。
数据加密：发送方发生数据前，使用密钥加密数据，发送数据密文。接受方接受密文后，使用密钥解密，获取数据。
数据校验：在加密数据的同时，生成数据完整性校验码，与数据密文拼接在一起。（简单理解：生成数据的哈希值，并使用密钥加密哈希值）接收方解密数据后，同样生成数据完整性校验码，与接收的相比，判断是否一致。

开源软件libssl.so提供TLS功能，应用只需调用接口，即可实现TLS协议。同时，libssl.so提供100+算法套件，可让应用选择不同的参数组合，1个算法套件，包含4个关键参数：

密钥生成：密钥生成协议
身份认证：证书算法类型
数据加密：加密算法类型
数据校验：哈希算法类型

例如，libssl.so中，常用的算法套件为：ECDHE-RSA-AES128-SHA256，该套件中，参数的含义如下：

密钥生成协议：ECDHE协议。（常见协议类型:DHE、ECDHE、RSA等）
证书算法类型：RSA
加密算法类型：AES-128
哈希算法类型：SHA-256

【需求分析】
vastbase支持TLS协议，当vsql与vastbase通信时，双方可使用TLS模块，生成密钥，并使用密钥加密、解密通信数据，包括：SQL语句、SQL执行结果等。
客户可能采用第三方工具，截取网络流量，获取传输中的SQL等数据，进行流量审计。但是，在使用TLS协议的情况下，网络中的数据是密文形式，无法进行流量审计。

vastbase提供1个GUC参数ssl_ciphers，用于配置TLS协议采用的算法套件，旧版本，该参数的取值范围如下：

ECDHE-ECDSA-AES256-GCM-SHA384
ECDHE-RSA-AES256-GCM-SHA384
DHE-RSA-AES256-GCM-SHA384
ECDHE-ECDSA-AES128-GCM-SHA256
DHE-RSA-AES128-GCM-SHA256
ECDHE-RSA-AES128-SHA256
ECDHE-ECDSA-SM4-CBC-SM3
4个仅tassl支持的国密算法套件

上述7个套件中，密钥生成协议为：ECDHE、DHE，此类DH协议，无法让第三方工具获取密钥。

本版本，新增4个算法套件：

AES128-SHA256
AES256-SHA256
AES128-GCM-SHA256
AES256-GCM-SHA384

上述4个套件，密钥生成协议为：RSA，该协议可让第三方工具获取密钥，使其可解密网络流量，获取SQL语句、SQL执行结果等。

【需求实现】
之前，vastbase限制ssl_ciphers的取值范围，仅放开7个算法套件，本版本，将新增放开4个算法套件。

实现时，仅修改ssl_ciphers的取值范围，新增支持4个算法套件[AES128-SHA256、AES256-SHA256、AES128-GCM-SHA256、AES256-GCM-SHA384]，4个算法套件将直接传递给libssl.so，内核不做任何处理。

因此，本需求无复杂设计。本文主要介绍完整的TLS协议工作原理。

1.2 实现方案

一、ECDHE与RSA的区别

此处简化ECDHE与RSA的步骤与算法，提取最核心的原理，方便快速理解。

一、ECDHE密钥协商协议
第三方工具、攻击者完全无法获取密钥。

client server
+-------------------------------------------+-----------------------------------
| <---- 0. 双方随机约定一些公开参数 ------> |
| 1. 生成随机私钥 client_priv
| 2. 基于client_priv，计算公钥 client_pub
| 3. 发送公钥 client_pub ------------>
 | 4. 接收公钥 client_pub
 | 5. 生成随机私钥 server_priv
 | 6. 基于server_priv，计算公钥 server_pub
 <------------ | 7. 发送公钥 server_pub
| 8. 接收公钥 server_pub
| 9. 基于client_priv，server_pub，计算密钥
 | 10. 基于server_priv，client_pub，计算密钥
（第9步和第10步，可以计算出相同的密钥）

简单举个例子
client server
+-------------------------------------------+-----------------------------------
| <----- 0. generate and send (2,11) ----> |
| 1. generate 8
| 2. caculate (8 * 2) % 11 = 5
| 3. send 5 ---------->
 | 4. receive 5
 | 5. generate 10
 | 6. caculate (10 * 2) % 11 = 9
 <------------ | 7. send 9
| 8. receive 9
| 9. key = (8 * 9) % 11 = 6
 | 10. key = (10 * 5) % 11 = 6

攻击者：截获网络流量，获取2,11,5,9，无法计算出密钥为6

二、RSA密钥交换协议

海量 10 需求 SSL协议

Wed, 03 Sep 2025 11:07:00 +0800

1 简介

1.1 目的

在应用与数据库传输数据时，为避免攻击者对数据进行窃听、篡改、伪造、重放等攻击，Vastbase支持采用TLS协议保障数据机密性与完整性。
通过TLS协议，应用传输数据指至服务端路程如下：

建立连接：与数据建立TCP连接
生成密钥(TLS)：采用TLS协议协商生成密钥(连接级)
加密数据(TLS)：使用密钥加密数据(SQL等)
发送数据：通过TCP协议，发送数据密文至数据库

客户可能采用第三方工具，截取网络流量，获取传输中的SQL等数据，进行流量审计。但是，在使用TLS协议的情况下，网络中的数据是密文形式，无法进行流量审计。为解决该问题，本文介绍如何让第三方工具获取密钥，以解密网络中的数据密文。

1.2 适用范围

本文适用于3.0.8 psu4以之后版本。未来本需求将同步至2.2.15版本。

1.3 术语定义、首字母缩写词和缩略语

SSL: Secure Sockets Layer，于保障网络通信安全的加密协议，早期协议，存在设计缺陷，目前由TLS协议替代。但是，SSL也可不特指SSL协议，可泛指所有通信安全加密协议。同时，由于历史原因，以及前向兼容，数据库中的很多参数与接口采用SSL命令，实际使用的是TLS协议。无需纠结TLS与SSL差异，vastbase中SSL等于TLS。
TLS: Transport Layer Security，更安全的传输加密协议。早期版本1.0,1.1已不安全，主流版本为1.2,1.3。

1.3 参考资料

原始需求：https://www.tapd.cn/tapd_fe/60475194/story/detail/1160475194001084569
openssl支持的所有cipers： https://docs.openssl.org/3.0/man1/openssl-ciphers/
ssl与tls原理：博客写了一点点，没整理

2 TLS协议支持第三方流量审计

2.1 功能简述

【需求现状】
目前，大部分第三方流量审计工具，可在一些特定场景下，解密由TLS协议加密后的数据。以vastbase为例，使用TLS协议分为以下阶段：

生成证书、私钥文件
vastbase端配置证书、私钥文件
vsql端配置证书、私钥文件
vsql连接vastbase
4.1 建立tcp连接
4.2 使用证书校验对方身份
4.3 双发协商选择算法套件：包括密钥生成协议、加密算法等
4.4 双方协商生成密钥
vsql与vastbase传输数据
5.1 发送数据前，使用密钥加密数据
5.2 发送数据密文
在4.3步骤中，可配置不同的密钥生成协议，对于其中一部分协议，在步骤4.4中，第三方工具可获取密钥，第步骤5.2中，第三方工具截取数据密文后，即可解密数据。
但是，4.3步骤中，目前vastbase仅支持2种密钥生成协议，这2种协议都无法让第三方工具获取密钥。

【密钥生成协议】
此处介绍2类常见的密钥生成协议：

一、DHE密钥协商协议
Vastbase目前支持的2种协议，都属于此类协议

client server
+-------------------------------------------+-----------------------------------
| <-------- 0. 双方随机约定一些参数 ------> |
| 1. 生成随机私钥 client_priv
| 2. 基于client_priv，计算公钥 client_pub
| 3. 发送公钥 client_pub ------------>
 | 4. 接收公钥 client_pub
 | 5. 生成随机私钥 server_priv
 | 6. 基于server_priv，计算公钥 server_pub
 <------------ | 7. 发送公钥 server_pub
| 8. 接收公钥 server_pub
| 9. 基于client_priv，server_pub，计算密钥
 | 10. 基于server_priv，client_pub，计算密钥
（第9步和第10步，可以计算出相同的密钥）

简单举个例子
client server
+-------------------------------------------+-----------------------------------
| <----- 0. generate and send (2,11) ----> |
| 1. generate 8
| 2. caculate (8 * 2) % 11 = 5
| 3. send 5 ---------->
 | 4. receive 5
 | 5. generate 10
 | 6. caculate (10 * 2) % 11 = 9
 <------------ | 7. send 9
| 8. receive 9
| 9. key = (8 * 9) % 11 = 6
 | 10. key = (10 * 5) % 11 = 6

攻击者：截获网络流量，获取2,11,5,9，无法计算出密钥为6

二、RSA密钥交换协议
该协议支持第三方工具解密流量，客户选择的工具已适配该协议。TLS还支持其他PSK、SRP等协议，但是，由于这些协议比较少见，且客户选择的工具未适配，本次不适配其他协议。

海量 11 需求逻辑复制性能优化

Fri, 06 Feb 2026 14:30:00 +0800

1 简介

1.1 目的

逻辑复制是一种在多个数据库实例之间复制数据的功能，通常用于从一个数据库实例中，将针对指定表的insert、delete、update等写操作，复制到其他另一个数据库实例。在数据库术语中，统一称逻辑复制的发送方为发布端，称接收方为订阅端。Oracle、Postgresql、Vastbase等数据库产品，均提供逻辑复制功能。

当前版本，逻辑复制性能较低，以tpcc场景为例，发布端40w tmpc时，订阅端的复制速度约10m/s。在滚动升级等场景，通过逻辑复制在不同实例间同步大量数据，要求逻辑复制性能达到70-100m/s。

发布端、订阅端均存在性能瓶颈，均需要优化。但是，由于交付时间较短，以及订阅端方案仍有瑕疵等因素，本版本交付发布端性能优化，下版本交付订阅端性能优化。

1.2 适用范围

本文主要用于向开发、测试等角色，介绍G100 3.0.9 psu2及之后版本，逻辑复制的性能优化的设计方向与使用方法。

1.3 术语定义、首字母缩写词和缩略语

发布端：逻辑复制场景，发送数据方。
订阅端：逻辑复制场景，接收数据方。

1.3 参考资料

Vastbase G100产品文档中逻辑复制使用介绍：https://docs.vastdata.com.cn/zh_CN/VastbaseG100/V3.0.8/1/f5c2ae8eb9744d429ad39c02438addf6

2 G100审计功能重构

2.1 功能简述

需求背景：逻辑复制使用

使用逻辑复制的流程如下：

发布端：配置逻辑复制

# 设置wal日志详细级别，设计身份等参数，重启集群
gs_guc set -D $PGDATA -c 'wal_level=logical'
gs_guc set -D $PGDATA -h "host all all 0.0.0.0/0 md5"
gs_guc set -D $PGDATA -h "host replication all 0.0.0.0/0 md5"
vb_ctl restart -D $PGDATA

发布端：创建表

CREATE TABLE pt1(c1 INT,c2 TEXT);
CREATE TABLE pt2(c1 INT, c2 TEXT);

发布端：创建发布，即指定哪些表需复制
```
CREATE PUBLICATION pub1 FOR TABLE pt1,pt2;
```
发布端：创建逻辑复制槽，用于存储复制状态等信息

海量透明加密设计

Mon, 23 Mar 2026 20:52:00 +0800

1 透明加密

1.1 功能简述

关于透明加密的基本概念，请看需求文档。
用户使用透明加密的示例如下：

CREATE TABLE t1 (c1 TEXT, c2 TEXT);

CREATE ENCRYPTION KEY tde_key WITH (source=local, password='pass.123');
CREATE ENCRYPTION POLICY ep1 FRO t1 KEY tde_key;

INSERT INTO t1 VALUES ('data1', 'data2');
INSERT INTO t1 VALUES ('data1', 'data2');
SELECT * FROM t1;

1.2 实现方案

1.2.1 整体架构

透明加密的核心目标，是通过数据加密方案，解决攻击者绕过数据库安全机制，直接从磁盘窃取数据的问题。
在加密数据后，需要确保不影响内核在数据上进行计算。因此，需要在存储层底层，对数据进行加密。另外，为确保存储底层能够识别哪些数据加密，哪些数据不加密，以及使用什么算法加密等，上层需传递加密信息。透明加密逻辑架构如下：

1.2.2 工作流程

为适配存储底层设计，同时兼顾加密性能，以Page为粒度进行加密，并且，在Page中，存储加密信息。

1.2.3 详细流程

一、启动进程

在启动进程阶段，故障恢复时，如果回放到属于加密表的xlog，涉及到解密Page，因此，需在故障恢复前加载密钥。

main # 1. 启动数据库进程（基于pg-16代码）
 PostmasterMain # 2. 启动postmaster进程
 SelectConfigFiles # 3. 读取GUC文件
 'tde_load_encryption_key' # 4. 读取密钥文件（后文介绍密钥如何生成）
 SysLogger_Start
 StartupDataBase # 5. 开始故障恢复
 StartupProcessMain
 StartupXLOG
 ReadControlFile
 PerformWalRecovery
 for loop:
 ReadRecord # 6. 读取xlog
 ApplyWalRecord # 7. 重放xlog
 GetRmgr.rm_redo
 ...
 heap_xlog_insert
 XLogReadBufferForRedo
 XLogReadBufferForRedoExtended
 XLogReadBufferExtended
 ReadBufferWithoutRelcache
 ReadBuffer_common
 smgrread # 8. 读取数据文件
 # 需解密，后文统一介绍
 ServerLoop
 for loop:
 ConnCreate
 BackendStartup
 BackendRun
 PostgresMain # 9. 启动postgres进程
 StartCheckpointer
 StartBackgroundWriter
 StartChildProcess
 AuxiliaryProcessMain
 BackgroundWriterMain # 10. 启动bgwriter进程

二、生成密钥

当前版本，所有表，使用同一个数据密钥。因此，暂时无需新增系统表，存储密钥对象。

海量透明加密需求

Fri, 20 Mar 2026 10:47:00 +0800

1 简介

1.1 目的

透明加密特性提供数据加密功能，核心原理是在数据库将数据存储至磁盘时，先加密再存储。
本需求将从0设计透明加密特性，在保障功能、性能、易用性、可用性、可维护性、可扩展性等的前提下，让特性达到商用标准。

1.2 适用范围

Vastbase V5版本。

1.3 术语定义、首字母缩写词和缩略语

TDE：Transparent Data Encryption，透明数据加密，由数据库提供的数据加密特性

1.4 参考资料

oracle 透明加密特性：https://docs.oracle.com/en/database/oracle/oracle-database/26/dbtde/preface.html
sql server 透明加密特性：https://learn.microsoft.com/en-us/sql/relational-databases/security/encryption/transparent-data-encryption?view=sql-server-ver17
oceanbase 透明加密特性：https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000004475958
kingbase 透明加密特性：https://docs.kingbase.com.cn/cn/KES-V9R1C10/safe/transparent-data-Encyption
dm8 透明加密特性：https://eco.dameng.com/document/dm/zh-cn/pm/storage-encryption.html#7.1.1%20%E5%85%A8%E5%BA%93%E5%8A%A0%E5%AF%86
gaussdb 透明加密特性：https://support.huaweicloud.com/intl/zh-cn/fg-gaussdb-dist-v8/gaussdb-18-0019.html

2 透明加密

2.1 功能简述

一、基本原理

通常，用户将数据传输给数据库后，数据库将数据存储到磁盘。攻击者可能利用多种数据库内部或外部漏洞，例如操作系统漏洞等，绕过数据库安全机制，直接从磁盘读取数文件，窃取用户数据。

透明加密，是一种由数据库提供的加密特性，可有效解决攻击者从磁盘窃取数据的问题。开启透明加密后，数据库将数据存储到磁盘时，先加密数据，再存储数据密文；数据库从磁盘读取数据时，先解密数据密文，再进行其他计算。用户访问透明加密表时，包括存储、读取数据等，与访问普通表无任何区别，加密和解密过程由数据库自动完成，即对用户透明。

二、竞品分析

几乎所有商用关系数据库中，都支持透明加密特性，包括oracle, sql server, oceanbase, kingbase, dm8等，postgresql不支持透明加密特性。
使用透明加密时，通常包括3个阶段：

定义用于加密的密钥
使用SQL语法，定义哪些对象需加密，不同产品，定义加密对象的粒度不同
使用SQL语法，访问透明加密表，以及进行其他运维等操作

各产品中，定义加密对象的SQL语法如下：

-- 一、oracle
CREATE TABLE t1(c1 INT, c2 TEXT ENCRYPT);
CREATE TABLESPACE ts1 DATAFILE .. ENCRYPTION USING 'AES192' ENCRYPT;
-- 二、sql server
CREATE DATABASE ENCRYPTION KEY WITH ALGORITHM = AES_256 ..
ALTER DATABASE db1 SET ENCRYPTION ON;
-- 三、oceanbase
CREATE TABLESPACE ts1 encryption = 'y'; -- mysql cmpt
CREATE TABLESPACE ts1 ENCRYPTION USING 'aes-256'; -- oracle cmpt
-- 四、kingbase
CREATE TABLESPACE ts .. WITH (ENCRYPTION = TRUE);
CREATE TABLE ts .. ENCRYPTED BY 'this is a key';
-- 五、dm8
intdb .. ENCRYPT_NAME ..
CREATE TABLESPACE .. ENCRYPT WITH ..
CREATE TABLE t1 (c1 INT, c2 INT ENCRYPT WITH ..);
-- 六、gaussdb
CREATE TABLE t1 .. WITH (enable_tde=on);

各产品中，按定义加密对象的粒度，区别如下：

海量 mac 设计

Mon, 23 Mar 2026 21:41:00 +0800

1 强制访问控制

1.1 功能简述

从实现的角度看，当用户执行SQL时，强制访问控制主要实现以下功能：

CREATE ACCESS POLICY ..：在系统表中，记录ACCESS POLICY，以及其中的LABLE等信息
CREATE TABLE ..：创建表时，如果设置acess_policy字段，则自动为表新增1列隐藏列，列名为access_label
INSERT ..：向表插入数据时，根据当前用户的write_label，自动为数据生成access_label列的值。
SELECT ..：从表查询数据时，根据当前用户的read_label，自动为查询语句添加过滤条件has_mac_permission(access_label, read_label)

另外，如果为表设置访问策略，需在索引中同时设置访问策略：

CREATE INDEX ..：自动为索引新增1列，列名为access_label

对于一些其他语法，也许单独适配，包括：

COPY ..：自动修改旧数据的access_label值

1.2 实现方案

1.2.1 整体流程

本文重点从源码角度，介绍强制访问控制策略如何基于隐藏列，实现强制访问控制，包括：创建、填充、匹配隐藏列等流程。
核心功能的大致流程如下：

User Vastbase Disk
+---------------------------------------------------+---------------------------------------------------------+
# 管理员
| 1. CREATE ACCESS POLICY .. LEVEL .. LABEL .. --> |
 | 2. 存储access policy至系统表vb_access_policy -->
 | 3. 存储access level至系统表vb_access_level -->
 | 4. 存储access label至系统表vb_access_label -->
| 5. CREATE TABLE .. (access_policy=..) --> |
 | 6. 识别是否设置access_policy
 | 7. 自动添加隐藏列access_label
 | 8. 存储access_policy至系统表pg_class -->
 | 9. 存储accessl_label定义至系统表pg_attribute -->
| 10. CREATE USER ..
 ACCESS POLICY .. READ LABEL .. WRITE LABEL --> |
 | 11. 存储access_policy, read_label, write_label至系统表pg_authid -->
# 普通用户
| 12. vsql -U username -W password --> |
| 14. set read_label = .. / write_label = .. --> |
 | 15. 查询pg_authid，判断read_label/write_label是否合法 <--
 | 16. 设置临时的read_label/write_label
 | 17. 如何用户未自动设置read_label/write_label，自动根据pgauthid设置
| 18. INSERT .. --> |
 | 19. 查询pg_class，判断表是否有access_policy <--
 | 20. 自动为隐藏列赋值，取值为write_label
| 21. SELECT .. --> |
 | 22. 查询pg_class，判断表是否有access_policy <--
 | 23. 语义分析
 | 24. 查询重写：自动新增过滤条件：WHERE has_mac_permission(access_label, read_label)
 | 24. 计划执行：扫描Tuple，根据过滤条件，过滤不满足权限检查的Tuple

1.2.2 详细流程

一、创建策略

当用户创建策略时，例如：

海量 mac 需求

Mon, 23 Mar 2026 21:40:00 +0800

1 简介

1.1 目的

本文主要包括以下关键内容：

介绍访问控制的基本概念
调研其他厂商实现强制控制的方式
设计Vastbase强制访问控制特性，介绍如何使用强制访问特性

1.2 适用范围

Vastbase V5版本。

1.3 术语定义、首字母缩写词和缩略语

MAC：Mandatory Access Control，强制访问控制，主体访问客体时，基于主体、客体属性，强制控制访问权限。
DAC：Discretionary Access Control，自主访问控制，数据拥有者可自行设置访问权限。

1.4 参考资料

oracle 强制访问控制（标签访问控制 RLS）：https://docs.oracle.com/en/database/oracle/oracle-database/26/olsag/part1.html#GUID-C20C62AE-2A30-45F9-AEEA-52A0D3286FBA
oceanbase 强制访问控制（兼容oracle）：https://www.oceanbase.com/docs/common-oceanbase-database-cn-1000000004475944
kingbase 强制访问控制：https://bbs.kingbase.com.cn/kingbase-doc/v8.6.7.24/safety/safety-guide/label-and-mac.html
dm 强制访问控制：https://eco.dameng.com/document/dm/zh-cn/pm/mandatory-access-control.html
GB/T-20009-数据库管理系统安全评估准则：https://drive.weixin.qq.com/s?k=AHUAfwdSAA82aDcvvD
postgresql 行级访问控制 RLS：https://www.postgresql.org/docs/current/ddl-rowsecurity.html

2 强制访问控制

2.1 功能简述

一、基本概念

访问控制的定义：对主体访问客体的行为，系统按照安全策略进行限制与管理的安全机制。
按安全策略分类，可将访问控制分为很多类，其中，常见的策略有：

自主访问控制DAC：客体的拥有者，可自行向其他主体赋予访问权限。
强制访问控制MAC：系统为主体、客体分配安全标签，通过主体、客体的安全标签控制访问权限，很多情况下，即使客体的拥有者也无法向其他主体赋予访问权限。
角色访问控制RBAC：不在本文讨论范围。

在数据库领域，主体通常指数据库用户，客体通常指数据库对象，例如DATABASE、SCHEMA、TABLE、COLUMN、ROW、FUNCTION等。
自主访问控制比较成熟，几乎所有关系数据库，都提供自主访问控制特性，例如，TABLE（客体）的属主（主体），可通过GRANT .. TO ..等语法，为其他用户（主体）赋予权限。
强制访问控制理论比较成熟，但是，除oracle支持强制访问控制，以及oceanbase等几款产品兼容oracle强制访问控制之外，大部分关系数据库不支持强制访问控制。

实现强制访问控制时，通常将主体、客体的安全标签，简化为安全等级，当主体访问客体时，比较主体、客体等级高低，以判断访问权限。在机密性场景，遵循不上读、不下写原则。在完整性场景，遵循不下读、不上写原则。

本需求将从0设计强制访问控制特性，在保障功能、性能、易用性、可用性、可维护性、可扩展性等的前提下，让特性达到商用标准。

二、竞品分析

oracle支持强制访问控制，客体是ROW，即行级强制访问控制。oceanbase、kingbase、dm的访问控制，与oracle一致。sql server、postgresql等其他产品不支持强制访问控制。
oracle强制访问控制使用示例如下：

-- 1 定义策略
SA_SYSDBA.CREATE_POLICY(policy_name => 'p1', column_name => 'lab_col1')
-- 2 定义级别
SA_COMPONENTS.CREATE_LEVEL(policy_name => 'p1', level_num => 1, short_name => 'x1', long_name => 'x1');
SA_COMPONENTS.CREATE_LEVEL('p1', 20, 'x2', 'x2');
SA_COMPONENTS.CREATE_LEVEL('p1', 30, 'x3', 'x3');
-- 3 定义组件
SA_COMPONENTS.CREATE_LEVEL(policy_name =>'p1', comp_num => 100, short_name => 'sec', long_name => 'security');
SA_COMPONENTS.CREATE_LEVEL('p1', 200, 'stg', 'storage');
-- 4 创建标签
SA_SYSDBA.CREATE_LABEL(policy_name => 'p1', label_tag => 'sec_normal', label_value => 'x1:security', data_label => TRUE);
SA_SYSDBA.CREATE_LABEL('p1', 'sec_leader', 'x3:security', false);
-- 5 为主体设置属性
SA_USER_ADMIN.SET_LEVELS(policy_name => 'p1', user_name => 'user1', max_level => 'x2', min_level => 'x1', default_level => 'x1', row_level => 'x1');
SA_USER_ADMIN.SET_COMPARTMENTS(policy_name => 'p1', user_name => 'user1', read_comps => 'sec', write_comps => 'sec', default_comps => 'sec', row_comps => 'sec');
-- 6 为客体设置属性
CREATE TABLE t1(c1 INT);
SA_USER_ADMIN.APPLY_TABLE_POLICY(policy_name=> 'p1', shema_name => 's1', table_name => 't1', table_options => 'READ_CONTROL, WRITE_CONTROL, CHECK_CONTROL', label_function => 'f_create_t1_label(level, comp)');
-- 7 插入数据（主动定义标签）
INSERT INTO t1 (c1, lab_col1)
VALUES (1, CHAR_TO_LABEL('p1', 'x1:sec'));

三、实现思路

在数据库领域，除oracle外，没有其他可借鉴的方案。oracle的设计，太复杂，易用性太低。
本需求将参考oracle的思想，简化oracle设计。

海量 15 设计逻辑复制性能优化

Wed, 06 May 2026 17:48:00 +0800

1 逻辑复制性能优化

1.1 功能简述

原理：
假设，发布端执行INSERT INTO t1 VALUES(1,'data1')，更改1行数据，产生1条wal日志。逻辑复制功能将读取这条wal，解码并生成1条message，将message发送至订阅端。订阅端应用这条message，等价于重新执行INSERT INTO t1 VALUES(1,'data1')。
问题：
308.1 psu1以及之前版本，逻辑复制性能较低。以tpcc场景为例，40w tmpc时，发布端产生wal日志速度约100m/s，订阅端的复制速度约10+m/s。
客户：
滚动升级场景中，备机停机升级，主机持续执行业务，备机升级后使用逻辑复制追赶主机数据。长存客户场景，主机产生wal日志速度约40-50m/s，旧版本逻辑复制速度10+m/s，由于逻辑复制速度太慢，备机无法追赶主机，最终导致升级失败。
优化
本需求设计与实现并行逻辑复制机制，大幅提高逻辑复制速度，在上述场景中，订阅端速度可达到70-90m/s。并行逻辑复制分为3个关键子机制：
1. 发布端多线程并行解码
2. 发布端与订阅端流复制传输协议
3. 订阅端多线程并行应用

1.2 实现方案

本章分3个章节，分别介绍3个关键子机制。

1.2.1 发布端并行解码机制

在旧版本中，发布端采用串行解码机制，只有1个walsender线程，串行执行：1次读取1条wal日志，解码1条wal生成1条message，缓存或发送message。

旧版本代码中，发布端有实现并行解码的代码，但是，无法直接使用，订阅端只能是工具，不能是数据库实例，且存在大量问题。本需求基于旧版本并行解码，实现权限的并行解码机制。

并行解码机制，将启动多个线程，包括1个reader、多个decoder、1个walsender，它们的功能如下：

reader：1次读取1条wal日志，将wal发送给decoder
decoder：1次接收1条reader发送的wal，解码生成message，将message发送给walsender
walsender：1次接收1条decoder发送的message，将message发送给订阅端

线程架构图如下：

lsn 1-10
 d1 1 4 collect 阻塞 1
 d2 2 5 2
 d3 3 6 3

1.2.2 发布端与订阅端流复制协议

一、握手阶段

订阅端与发布端建立连接时，订阅端会根据CRETE SUBSCRIPTION语法设置的参数，生成连接命令，根据连接命令，发布端和订阅端决定采用哪种通信协议，究竟是采用事务复制协议（旧版本）还是流复制协议（新版本）。

事务复制协议（旧版本）

订阅端发送的连接命令如下：

START_REPLICATION SLOT "$slot_name" LOGICAL $start_lsn
 (proto_version '3', publication_names '"$publication_name"')

流复制协议（新版本）

如果CRETE SUBSCRIPTION时，指定worker_number>1，即启用并行逻辑复制机制，将使用新的连接命令，订阅端发送的连接命令如下：

START_REPLICATION SLOT "$slot_name" LOGICAL $start_lsn
 (proto_version '3', publication_names '"$publication_name"'， streaming 'extreme', parallel-decode-num '20', max-recordbuffer-in-memory '100', max-txn-in-memory '100')

上述命令中新增了多个参数：

海量 15 需求逻辑复制性能优化

Wed, 06 May 2026 10:05:00 +0800

1 简介

1.1 目的

当前版本，逻辑复制性能较低。以tpcc场景为例，发布端40w tmpc时，产生wal日志速度约100+m/s，订阅端的复制速度约10+m/s。在滚动升级场景，主机和备机可能是不同的产品版本，主备复制数据时，不能使用物理复制，只能使用逻辑复制。在长存客户场景中，主机产生wal日志速度在50+m/s左右，备机使用逻辑复制，复制速度约10+m/s，备机将追赶不上主机进度，导致滚动升级失败。

主a 备b 备c
+-----------------------+---------------------------+-----------------------------
|1 ==>执行业务
|2 开始滚动升级，暂停流复制 lag=400M
 |3 暂停流复制（物理复制）
|4 创建逻辑复制槽 lsn1=1G
 |5 恢复流复制
 |6 物理复制追赶，到逻辑复制槽
 |6 开始单节点升级
 |7 [升级] 停止进程
 |8 [升级] 替换二进制等
 |9 [升级] 启动进程
 |10 单节点升级成功
|11 持续执行业务 lsn2=2G
 |12 创建订阅，启动逻辑复制，lsn1=1G
 |13 逻辑复制开始追赶（初始差距：lsn2-lsn1)
|14 持续执行业务 lsn3=2.5G
 |15 逻辑复制持续追赶 lsn=1.6G
|16 (可重置lag)
 |17 差距持续缩小（从lsn2-lsn1降低到lag）
|18 发送停机命令
|19 停止业务
 |20 差距持续缩小，从lag缩小至0
|21 停止进程成功

因此，需大幅提高逻辑复制速度，在长存客户场景中，逻辑复制速度至少需达到70+m/s。目前，发布端、订阅端均存在性能瓶颈，均需要优化。

1.2 适用范围

G100 3.0.9 psu2及之后版本

1.3 术语定义、首字母缩写词和缩略语

发布端：逻辑复制场景，发送数据方。
订阅端：逻辑复制场景，接收数据方。

1.4 参考资料

Vastbase G100产品文档中逻辑复制使用介绍：https://docs.vastdata.com.cn/zh_CN/VastbaseG100/V3.0.8/1/f5c2ae8eb9744d429ad39c02438addf6
oracle goldengate并行复制：https://oracle.hydrogen.sagittarius.connect.product.adaptavist.com/en/database/goldengate/core/26/coredoc/replicat-parallel-replicat.html#GUID-F1CD8E03-8DA1-4A78-95D3-C0516F1DA09A

2 逻辑复制性能优化

2.1 功能简述

一、逻辑复制使用示例

使用逻辑复制，可概括为3个阶段：

G100学习笔记

Fri, 11 Sep 2026 12:09:29 +0800

G100学习笔记

1. page相关

1.1 page的关键数据结构

typedef struct {
 PageXLogRecPtr pd_lsn; /* 当前页的最后一次修改对应的WAL记录的LSN */
 uint16 pd_checksum; /* 当前页的checksum校验和，用来维护页面的完整性，使用特定的算法生成固定大小的值，在写入时计算，读取时校验，读取时计算checksum，与本记录比对 */
 uint16 pd_flags; /* 页状态标志位 */
 uint16 pd_lower; /*
}

Babelfish搭建指南

Fri, 27 Feb 2026 14:30:01 +0800

Babelfish 编译环境搭建指南

适用环境：CentOS 7，离线环境，vastbase-server + sqlserver-extensions

一、创建用户

# 创建用户并设置密码
useradd vast
echo "vast:gauss@123" | chpasswd

# 授予 sudo 权限（加入 wheel 组）
usermod -aG wheel vast

# 验证
id vast

二、配置环境变量

将以下内容写入 ~/.bash_profile，每次登录自动生效：

cat >> ~/.bash_profile << 'EOF'
# Babelfish 基础路径
export BABELFISH_HOME=~/vastbase-server/install
export BINARYLIBS=~/vastbase-server/binarylibs
export GCC_PATH=$BINARYLIBS/buildtools/gcc7.3

# 编译器
export CC=$GCC_PATH/gcc/bin/gcc
export CXX=$GCC_PATH/gcc/bin/g++

# cmake（优先使用项目自带版本，放在 PATH 最前面）
export PATH=$BINARYLIBS/buildtools/cmake/bin:$GCC_PATH/gcc/bin:$BABELFISH_HOME/bin:$PATH

# 动态库路径
export LD_LIBRARY_PATH=$GCC_PATH/gcc/lib64:$BABELFISH_HOME/lib:$BINARYLIBS/kernel/dependency/openssl/comm/lib:$LD_LIBRARY_PATH

# cmake 变量（防止 Makefile 调用系统旧版本）
export cmake=$(which cmake)

# PG 相关
export PG_CONFIG=$BABELFISH_HOME/bin/pg_config
export PG_SRC=`pwd`
EOF

source ~/.bash_profile

验证工具版本：

避免用户错误使用到pg插件

Wed, 25 Feb 2026 10:15:33 +0800

基本概念

这里是融合版的一个需求，属于兼容性需求类别，主要实现的是一个黑名单，是要把一个列表中的多个插件不允许在MSSQL兼容安装包中出现，或只能在5432端口（PG模式）中使用，不能在1433端口（MSSQL模式）中使用。

初步分析

根据需求列表，可以基本将需要修改的插件分为三类：

禁止在双端口安装使用；
在5432端口允许使用，1433端口禁止安装使用；
双端口都允许使用；

其中，需求描述特别提到，允许在编译阶段进行修改，由此可以对应的提出三类插件的修改方案：

在编译阶段不安装，也就是在contrib/Makefile中的SUBDIR安装插件，删除这些不允许在双端口安装的插件；
在hooks.c中增加一个名单，名单中包含这些允许在5432不允许在1433安装的插件，首先检测当前dialect是否为tsql，如果为tsql，检查是否是T_CreExtensionStmt，如果是则检查插件名单是否在这个名单之内，如果没有则放行，有则报错；
不做任何处理；

理论上，以上方案实施后，能够达到双端口不可用则直接无法找到插件，用户自行安装则不保证可能出现的任何问题；对于5432可用1433不可用，会进行报错；其他类型不做处理；应该可以达到需求描述的目的实现；

边界考虑

由于删除了某些插件编译且对某些插件在一定场景进行了屏蔽，考虑数据库升级场景，如果以前使用过此插件，现在进行了屏蔽，可能导致升级失败；

灵活性

现在的屏蔽方式是使用直接修改编译文件与硬编码名单的方式实现，如果在一个版本内，由于某些特殊原因想启用已屏蔽的插件，则在当前版本是无法实现的。如果将名单作成guc参数，则可以提供灵活性，但是一旦被手动篡改，则无法预料可能产生的问题；

深度优先遍历

Tue, 24 Feb 2026 12:02:52 +0800

今天的每日一题：1202. 从根到叶的二进制数之和。

简单来说，就是给定一颗层序遍历的数组，表示一颗树，例如：

输入：root = [1,0,1,0,1,0,1]
输出：22
解释：(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22

可以表示为：

思路就是使用dfs来遍历这个树，代码为：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode() : val(0), left(nullptr), right(nullptr) {}
 * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
 int dfs(TreeNode *root, int val) {
 if (root == nullptr)
 return 0;

 val = val << 1 | root->val;
 if (root->left == nullptr && root->right == nullptr)
 return val;

 return dfs(root->left, val) + dfs(root->right, val);
 }

 int sumRootToLeaf(TreeNode* root) {
 return dfs(root, 0);
 }
};

拿到这个题就知道用dfs，但是这个计算的方式确实没想到，二进制移位操作，并且使用局部变量保存临时结果，就不需要复杂的字符串拼接然后转换10进制了，例如上例：

逻辑复制

Tue, 10 Feb 2026 16:15:52 +0800

基本概念

逻辑复制是数据同步的一种方式，逻辑二字主要指的是传输数据的格式，与之相对的是物理复制。

逻辑数据格式

逻辑数据格式是指，能够由一定规则描述的，符合SQL直觉的一种数据格式，例如：

[MsgType：Insert，Relation：test，New Tuple：[a, int, 100]]

从这种数据格式上，能够通过解析等方式，将数据还原为SQL语句，这也同时表现了逻辑复制的第一个特点：无视物理结构上的差异，可以在异构、跨版本的数据库之间进行数据同步。

接上例，通过一定的解析步骤，我们总能够得到：

Insert into test(a) values 100::int;

对于不同内核来说，可能在语法上稍有差异，但只需要修改一些解析方式，也能够得到自身看的懂、可以运行的命令。

与物理复制的区别

逻辑复制的另外一个特点，是相对于另一种主流的数据同步方式：物理复制，来作为比较的。

几乎所有的数据库内核，在进行数据存储的时候，都是采用随机写的方式，最大化利用性能优势，将数据存储在磁盘上。那么从物理上看，一个relation的所有数据，可能并不是连续的：他们可能分布在不同的page上，由指针进行连接。那么从磁盘角度看，一个page的分布，可能是这样的：

--------------
Page Header
--------------
Tuple 1 for r1
--------------
Tuple 2 for r1
--------------
Tuple 1 for r2
--------------
Tuple 1 for r3
--------------
Tuple 2 for r2
--------------

如此一来，想要在物理层面进行数据传输时，以page为单位，是无法将不同relation的tuple分开的，也就是细粒度不够。

逻辑复制的另一个特点，是可以以表为单位，进行数据同步，由一个Reader完成。

Reader逐行的去读取物理中的tuple，筛选那些符合要求的tuple，进行下一步工作。

逻辑复制提高的数据同步的细粒度，可以在库、表、甚至行上进行数据过滤，显然是一种更灵活的同步方式，在某些场景下，其效果更好，常见的有：

应用场景

某数据库使用厂商需要进行版本升级，但升级前后版本由于迭代问题，在物理存储上存在差异，导致无法进行直接替换；

某数据库使用厂商需要将原有的数据库数据迁移到一款新的数据库产品上，而这两个数据库的内核架构完全不同，物理存储存在本质差异；

某厂商部门之间使用的数据库产品不同，但部门之间存在协作，需要进行数据传递； …

架构

如图所示，逻辑复制功能，是两个实例（或生产者与消费者）之间完成的数据同步，通常我们把作为数据源端的实例，称为发布端（Publisher），而准备接收数据并进行回放的实例称为订阅端（Subscriber）。

发布端

发布端的组成部分，共分为以下几个部分：WALReader、Decoder、Sender，通常是由三个独立的线程，按照其角色完成不同的工作：

WALReader：主要完成对Xlog日志的读取，即从磁盘上将当前已罗盘的Xlog record读取到内存，并发送给Decoder；
Decoder：解码线程，由于WALReader发送来的数据，是物理层面的记录，Decoder会按照特定的规则，将物理信息转换为逻辑信息，从内存上看，使用一个结构体，保存Xlog record中的xid、LSN、DMLType等信息。同时，Decoder还需要将这些信息，按照约定好的协议（Protocol）将数据进行打包，其中应用最广泛的端到端协议是pgoutput（后面会介绍他的协议格式以及细节实现）。Decoder会将这些按照协议进行拼接的逻辑数据存储到私有内存中，当达到一定条件时，将数据发送给Sender线程执行发送。
Sender：将Decoder发送来的数据通过网络发送给订阅端。

发布端如何保证事务一致性

对于数据同步来说，最重要的是事务一致性，如果不能保证一致性，那么逻辑复制将是毫无意义的。而要保证事务一致性，通常主要责任在于发布端，发布端需要确保自己发送逻辑信息的顺序，是严格的，即使不能保证发送顺序一定与WAL日志写入顺序完全一致，但必须保证事务的最终一致性。为了保证事务一致性，在发布端，通常会有以下几个部分保证：

严格按照commit顺序进行事务发送：事务的提交顺序非常重要，Decoder解码到一条逻辑数据时，并不会立刻发送给Sender，而是将条变更存储起来，直到解码到该事务对应的commit，才将整个事务完发送；
错误重发：当订阅端接收到一个事务的commit时，即代表这个事务经传输完毕，订阅端会发送一个确认LSN给发布端，发布端需要确认LSN是在当前处理LSN的前面，如果此时LSN发生错乱，发布端会立即这条返回的LSN开始，重新发送这些变更；
commit时间确认：在Decoder将Xlog信息解码为逻辑协议信息时对于某些类型的消息，会携带commit timestampz，这是该事务提时的瞬时时间戳；

发布端对于内存的管理

在业务系统中，有时不可避免的会出现大事务，通常包含几M甚至百M的事务变更数据，在逻辑复制模块中，上文提到，通常是将所有事务存储于内存，当遇到该事务的commit时，才进行发送。对于这种大事务来说，如果多几条，可能很容易造成内存压力，引起CPU抖动，有影响系统整体性能的可能性。

为了保证系统整体性能，当遇到这种大事务的时候，通常会设计一个内存阈值，当在内存中已经存储了多条事务变更时，一旦当前内存占用达到阈值，发布端会选择当前内存中一个最大的事务（不一定是完整的，只是transaction size最大）spill to disk；诚然，这会带来一定的IO开销，因为当我们读到被spill的事务的commit时，需要把它从磁盘上读出来，但相比于其带来的内存负荷，这是合理的取舍。

0.Readme

Tue, 10 Feb 2026 16:05:44 +0800

关于

把这里当成第一步，开始积累自己的东西，当有一天面对外部变化，能够从从容容、游刃有余。

我是贾旭辉，我希望能够养成良好的习惯，开始随手记录一些工作中、生活中积累到的东西。

种下一棵树最好的时间是十年前，其次就是现在了。

 -- 2026.02.10