PostgreSQL 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: 自带的一个常规库；

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)

安装调试工具

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()

PostgreSQL 1-4 存储模块

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

摘要

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

1 概述

1.1 PostgreSQL的使用流程

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

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

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

运维

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，所以，接下来的对话，都和这件事有关。

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

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)

协议编码

消息通用格式

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 加密未开启时直接报错。这是易用性设计里最重要的一条：不要把一个"配错了就静默泄密"的组合留给用户。

工具 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

强制访问控制

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

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

执行

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

安装外部集群

避免用户错误使用到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, 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时，需要把它从磁盘上读出来，但相比于其带来的内存负荷，这是合理的取舍。