PostgreSQL的存储系统二：REDOLOG文件存储结构二

概述REDOLOG文件里的用户数据和数据文件里的用户数据存储结构相同          几个月前同事给台湾一家公司培训《pg9 ad admin》时，有个学员提及WAL里记录的内容为Query时的SQL语句（比如insert等），同事告知WAL里记录的tuple信息，而非SQL，该学员坚持里面是SQL或SQL+tuple，并说oracle的redo日志里记录的是SQL（不知到这个从哪里知道的，也许是日

REDolOG文件里的用户数据和数据文件里的用户数据存储结构相同

几个月前同事给台湾一家公司培训《pg9 ad admin》时，有个学员提及WAL里记录的内容为query时的sql语句（比如insert等），同事告知WAL里记录的tuple信息，而非sql，该学员坚持里面是sql或sql+tuple，并说oracle的redo日志里记录的是sql（不知到这个从哪里知道的，也许是日志挖掘出来sql的缘由吧）。便看了一下源码（还是开源的好）。

前面我写过一篇文章《Postgresql的存储系统二：REDolOG文件存储结构》，见地址http://beigang.iteye.com/blog/1565121或http://blog.csdn.net/beiigang/article/details/7680905，其中提到Pg XLOG文件的存储格式大致如下：

<PageheaderData>

<XLogRecord>

<rmgr-specific data>

<BkpBlock>

<XLogRecdata>里面包括<CheckPoint>等

<BkpBlock>

<XLogRecdata>

<BkpBlock>

<XLogRecdata>

……

用户相关的数据写在XLogRecdata结构（定义见下面）的buffer成员里，但具体写成什么样子没有提及，正好这儿再深入讨论一下。

typedefstruct XLogRecdata

{

char *data; /* 资源管理器包含数据的开始 */

uint32 len; /* 资源管理器包含数据的长度 */

Buffer buffer; /* 有相应数据的buffer，如果有的话 */

bool buffer_std; /* buffer是否有标准pd_lower/pd_upper头 */

struct XLogRecdata *next; /* 链里的下一个结构 */

} XLogRecdata;

为了说清楚这个问题，跑了个例子如下：

INSERT INTO table1(ID,Gname) VALUES(18,’GangBei’);

看这个例子涉及的调用流程前，先回顾一下pg服务进程的调用流程，一切就绪后进入无限循环，等候客户端指令，

Postgres服务进程调用流程图

这个例子的调用流程和《Postgresql服务过程中的那些事二：Pg服务进程处理简单查询》系列博文中的流程大致相同，也是调用exec_simple_query方法，和前面《Postgresql服务过程中的那些事二：Pg服务进程处理简单查询》中select例子不同的是，本节中insert的例子在portalrun方法里调用了执行器的ExecInsert方法，最终调用了heap_insert方法，在这个方法里完成了记录写入数据文件，并调用了XLogInsert方法，完成了XLOG的WAL日志写入。更具体的方法调用流程参见下面的调用流程图，其他和《Postgresql服务过程中的那些事二：Pg服务进程处理简单查询》基本相同的部分略去。

Insert sql 语句调用流程

在heap_insert方法里，组装好tuple，调用RelationGetBufferForTuple方法找到shmem里缓存数据文件块的buffer，调用RelationPutHeapTuple方法，把组装好的元组放到合适的buffer中合适的位置；然后组装XLogRecdata类型变量rdata，把buffer赋给XLogRecdata的成员buffer，接着调用XLogInsert方法，并传入rdata，在XLogInsert方法里，用memcpy方法把rdata写入shmem对应的cache里，最后pg都是通过 *** 作系统接口I/O接口把WAL日志和数据写入对应的文件。

既然XLOG里写的 Insert的wal日志里的用户数据和数据文件中的一样，那我们简单看一下pg中数据文件里的tuple，tuple存放在堆中，一个tuple就是一行表记录，在数据文件的页里存放的结构如下图：

数据文件页面布局图

元组结构图

元组头结构和其字段表示意义见下面：

typedefstruct HeapTupleheaderData

{

union

{

HeapTupleFIEldst_heap;

DatumTupleFIEldst_datum;

} t_choice;

ItemPointerDatat_ctID; /* current TID of this or newer tuple */

/* FIElds below here must match MinimalTupleData! */

uint16 t_infomask2; /* number of attributes + varIoUs flags */

uint16 t_infomask; /* varIoUs flag bits,see below */

uint8 t_hoff; /* sizeof header incl. bitmap,padding */

/* ^ - 23 bytes - ^ */

bits8 t_bits[1]; /* bitmap of NulLs -- VARIABLE LENGTH */

/* MORE DATA FolLOWS AT END OF STRUCT */

} HeapTupleheaderData;

typedefstruct HeapTupleFIElds

{

TransactionIDt_xmin; /* inserting xact ID */

TransactionIDt_xmax; /* deleting or locking xact ID */

union

{

CommandID t_cID; /* inserting or deleting command ID,or both */

TransactionIDt_xvac; /* old-style VACUUM FulL xact ID */

} t_fIEld3;

} HeapTupleFIElds;

typedefstruct DatumTupleFIElds

{

int32 datum_len_; /* varlena header (do not touch directly!) */

int32 datum_typmod; /* -1,or IDentifIEr of a record type */

OID datum_typeID; /* composite type OID,or RECORDOID */

/*

* Note: fIEld ordering is chosen with thought that OID might someday

* wIDen to 64 bits.

*/

} DatumTupleFIElds;

typedefstruct ItemPointerData

{

BlockIDDataip_blkID;

OffsetNumberip_posID;

}

Postgresql的元组头结构是MVCC算法的基础。这个以后再说吧。

下面把heap_insert方法和XLogInsert方法贴到了下面，为了突显主题，删掉了其余代码，并把XLOG内容相关变量和方法置为红色，方便串读。

OID

heap_insert(Relation relation,HeapTuple tup,CommandID cID,

int options,BulkInsertState bistate)

{

TransactionID xID = GetCurrentTransactionID();

HeapTuple heaptup;

Buffer buffer;

bool all_visible_cleared = false;

/*1 组装元组头信息 */

tup->t_data->t_infomask &= ~(HEAP_XACT_MASK);

tup->t_data->t_infomask2 &= ~(HEAP2_XACT_MASK);

tup->t_data->t_infomask |= HEAP_XMAX_INVALID;

HeapTupleheaderSetXmin(tup->t_data,xID);

HeapTupleheaderSetCmin(tup->t_data,cID);

HeapTupleheaderSetXmax(tup->t_data,0);

tup->t_tableOID = RelationGetRelID(relation);

heaptup = tup;

/*2 Find buffer to insert this tuple into */

buffer = RelationGetBufferForTuple(relation,heaptup->t_len,

InvalIDBuffer,options,bistate);

/*3

* We're about to do the actual insert -- check for conflict at the

* relation or buffer level first,to avoID possibly having to roll back

* work we've just done.

*/

CheckForSerializableConflictIn(relation,NulL,buffer);

/*4 NO EREPORT(ERROR) from here till changes are logged */

START_CRIT_SECTION();

RelationPutHeapTuple(relation,buffer,heaptup)

MarkBufferDirty(buffer);

/* XLOG stuff */

if (!(options & HEAP_INSERT_SKIP_WAL) && RelationNeedsWAL(relation))

{

xl_heap_insert xlrec;

xl_heap_header xlhdr;

XLogRecPtr recptr;

XLogRecdata rdata[3];

Page page = BufferGetPage(buffer);

uint8 info = XLOG_HEAP_INSERT;

xlrec.all_visible_cleared = all_visible_cleared;

xlrec.target.node = relation->rd_node;

xlrec.target.tID = heaptup->t_self;

rdata[0].data = (char *) &xlrec;

rdata[0].len = SizeOfheAPInsert;

rdata[0].buffer = InvalIDBuffer;

rdata[0].next = &(rdata[1]);

xlhdr.t_infomask2 = heaptup->t_data->t_infomask2;

xlhdr.t_infomask = heaptup->t_data->t_infomask;

xlhdr.t_hoff = heaptup->t_data->t_hoff;

/*

* note we mark rdata[1] as belonging to buffer; if XLogInsert decIDes

* to write the whole page to the xlog,we don't need to store

* xl_heap_header in the xlog.

*/

rdata[1].data = (char *) &xlhdr;

rdata[1].len = SizeOfheapheader;

rdata[1].buffer = buffer;

rdata[1].buffer_std = true;

rdata[1].next = &(rdata[2]);

/* PG73FORMAT: write bitmap [+ padding] [+ oID] + data */

rdata[2].data = (char *) heaptup->t_data + offsetof(HeapTupleheaderData,t_bits);

rdata[2].len = heaptup->t_len - offsetof(HeapTupleheaderData,t_bits);

rdata[2].buffer = buffer;

rdata[2].buffer_std = true;

rdata[2].next = NulL;

recptr = XLogInsert(RM_HEAP_ID,info,rdata);

PageSetLSN(page,recptr);

PageSetTli(page,ThisTimelineID);

}

END_CRIT_SECTION();

UnlockReleaseBuffer(buffer);

pgstat_count_heap_insert(relation);

return HeapTupleGetoID(tup);

}

XLogRecPtr

XLogInsert(RmgrID rmID,uint8 info,XLogRecdata *rdata)

{

XLogCtlinsert *Insert = &XLogCtl->Insert;

XLogRecord *record;

XLogContRecord *contrecord;

XLogRecPtr RecPtr;

XLogRecPtr WriteRqst;

uint32 freespace;

int currIDx;

XLogRecdata *rdt;

Buffer dtbuf[XLR_MAX_BKP_BLOCKS];

bool dtbuf_bkp[XLR_MAX_BKP_BLOCKS];

BkpBlock dtbuf_xlg[XLR_MAX_BKP_BLOCKS];

XLogRecPtr dtbuf_lsn[XLR_MAX_BKP_BLOCKS];

XLogRecdata dtbuf_rdt1[XLR_MAX_BKP_BLOCKS];

XLogRecdata dtbuf_rdt2[XLR_MAX_BKP_BLOCKS];

XLogRecdata dtbuf_rdt3[XLR_MAX_BKP_BLOCKS];

pg_crc32 rdata_crc;

uint32 len,

write_len;

unsigned i;

TRACE_POSTGREsql_XLOG_INSERT(rmID,info);

/*

* Here we scan the rdata chain,determine which buffers must be backed

* up,and compute the CRC values for the data.

*/

START_CRIT_SECTION();

/* Now wait to get insert lock */

LWLockAcquire(WAlinsertLock,LW_EXCLUSIVE);

/* Compute record's XLOG location */

currIDx = Insert->currIDx;

INSERT_RECPTR(RecPtr,Insert,currIDx);

/*

* Append the data,including backup blocks if any

*/

/* 把rdata中的数据写入XLOG */

while (write_len)

{

while (rdata->data == NulL)

rdata = rdata->next;

if (freespace > 0)

{

if (rdata->len > freespace)

{

memcpy(Insert->currpos,rdata->data,freespace);

rdata->data += freespace;

rdata->len -= freespace;

write_len -= freespace;

}

else

{

memcpy(Insert->currpos,rdata->len);

freespace -= rdata->len;

write_len -= rdata->len;

Insert->currpos += rdata->len;

rdata = rdata->next;

continue;

}

}

/* Use next buffer */

updrqst = AdvanceXlinsertBuffer(false);

currIDx = Insert->currIDx;

/* Insert cont-record header */

Insert->currpage->xlp_info |= XLP_FirsT_IS_CONTRECORD;

contrecord = (XLogContRecord *) Insert->currpos;

contrecord->xl_rem_len = write_len;

Insert->currpos += SizeOfXLogContRecord;

freespace = INSERT_FREESPACE(Insert);

}

LWLockRelease(WAlinsertLock);

XactLastRecEnd = RecPtr;

END_CRIT_SECTION();

return RecPtr;

}

下面这个图是WAL日志中存放的有关的INSERT、UPDATE、DELETE *** 作的内容，该图引自《Internals Of Postgresql Wal》

就到这儿吧。

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

转载请著明出处： blog.csdn.net/beiigang beigang.iteye.com

总结

以上是内存溢出为你收集整理的PostgreSQL的存储系统二：REDOLOG文件存储结构二全部内容，希望文章能够帮你解决PostgreSQL的存储系统二：REDOLOG文件存储结构二所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。