Shulou(Shulou.com)06/01 Report--

This section provides a brief introduction to the implementation logic of the XLogRecordAssemble function, which assembles XLOG record from registered data and buffers into the XLogRecData chain in preparation for XLOG Record insertion.

I. data structure

Global static variable

Global variables used by XLogRecordAssemble include hdr_rdt/hdr_scratch/rdatas and so on.

/ * flags for the in-progress insertion * / / the tag information used in the insertion process static uint8 curinsert_flags = 0 These are used to hold the record header while constructing a record * *. * 'hdr_scratch' is not a plain variable, but is palloc'd at initialization, * because we want it to be MAXALIGNed and padding bytes zeroed. * the header information of the record is usually stored when building a XLOG Record. * 'hdr_scratch' is not a plain variable, but is initialized with palloc during initialization, * because we want the variable to be MAXALIGNed and populated by 0x00. * For simplicity, it's allocated large enough to hold the headers for any * WAL record. * for simplicity, this variable allocates enough space in advance to store all WAL Record header information. * / static XLogRecData hdr_rdt;static char * hdr_scratch = NULL;#define SizeOfXlogOrigin (sizeof (RepOriginId) + sizeof (char)) # define HEADER_SCRATCH_SIZE\ (SizeOfXLogRecord +\ MaxSizeOfXLogRecordBlockHeader * (XLR_MAX_BLOCK_ID + 1) +\ SizeOfXLogRecordDataHeaderLong + SizeOfXlogOrigin) / * * An array of XLogRecData structs, to hold registered data. * XLogRecData structure array to store registered data. * / static XLogRecData * rdatas;static int num_rdatas; / * entries currently used * / / the allocated space static int max_rdatas; / * allocated size * / / whether to call the XLogBeginInsert function static bool begininsert_called = false;static XLogCtlData * XLogCtl = NULL;/* flags for the in-progress insertion * / static uint8 curinsert_flags = 0 * A chain of XLogRecDatas to hold the "main data" of a WAL record, registered * with XLogRegisterData (...). * store the XLogRecDatas data link of WAL Record "main data" * / static XLogRecData * mainrdata_head;static XLogRecData * mainrdata_last = (XLogRecData *) & the mainrdata size of a location in the mainrdata_head;// chain static uint32 mainrdata_len; / * total # of bytes in chain * / / * ProcLastRecPtr points to the start of the last XLOG record inserted by the * current backend. It is updated for all inserts. XactLastRecEnd points to * end+1 of the last record, and is reset when we end a top-level transaction, * or start a new one; so it can be used to tell if the current transaction has * created any XLOG records. * ProcLastRecPtr points to the beginning of the last XLOG record inserted by the current backend. * it updates for all inserts. * XactLastRecEnd points to + 1 at the end of the last record, * and resets when ending a top-level transaction or starting a new transaction; * therefore, it can be used to determine whether any XLOG records have been created by the current transaction. * While in parallel mode, this may not be fully up to date. When committing, * a transaction can assume this covers all xlog records written either by the * user backend or by any parallel worker which was present at any point during * the transaction. But when aborting, or when still in parallel mode, other * parallel backends may have written WAL records at later LSNs than the value * stored here. The parallel leader advances its own copy, when necessary, * in WaitForParallelWorkersToFinish. * in parallel mode, this may not be entirely up to date. * at the time of commit, the transaction can be assumed to overwrite all xlog records of the user background process or parallel worker processes that occur during the transaction. * however, when aborted, or when still in parallel mode, other parallel background processes may have written WAL records in a later LSNs, * instead of the values stored here. * the leader of the parallel processing process pushes its own copy in WaitForParallelWorkersToFinish when needed. * / XLogRecPtr ProcLastRecPtr = InvalidXLogRecPtr;XLogRecPtr XactLastRecEnd = InvalidXLogRecPtr;XLogRecPtr XactLastCommitEnd = InvalidXLogRecPtr;/* For WALInsertLockAcquire/Release functions * / for the WALInsertLockAcquire/Release function static int MyLockNo = 0 position static bool holdingAllLocks = false

Macro definition

The flags used by the XLogRegisterBuffer function

/ * flags for XLogRegisterBuffer * / the flags#define REGBUF_FORCE_IMAGE 0x01 / * used by the XLogRegisterBuffer function to enforce full-page-write;force a full-page image * / # define REGBUF_NO_IMAGE 0x02 / * does not require FPI;don't take a full-page image * / # define REGBUF_WILL_INIT (0x04 | 0x02) / * reinitialize page on playback (indicates NO_IMAGE) * page will be re-initialized at * replay (implies NO_IMAGE) * / # define REGBUF_STANDARD 0x08 / * Standard page layout (data between pd_lower and pd_upper will be skipped) * page follows "standard" page layout * (data between pd_lower and pd_upper * will be skipped) * / # define REGBUF_KEEP_DATA 0x10 / * include data even if a full-page image * is taken * / / * * Flag bits for the record being inserted, set using XLogSetRecordFlags (). * / # define XLOG_INCLUDE_ORIGIN 0x01 / * include the replication origin * / # define XLOG_MARK_UNIMPORTANT 0x02 / * record not important for durability * /

XLogRecData

The functions in xloginsert.c construct a chain of XLogRecData structures to identify the last WAL record

/ * * The functions in xloginsert.c construct a chain of XLogRecData structs * to represent the final WAL record. * the function in xloginsert.c constructs a XLogRecData structure chain to identify the next structure in the last WAL record * / typedef struct XLogRecData {/ / chain. If none, it is the starting address of NULL struct XLogRecData * next; / * next struct in chain, or NULL * / rmgr data starting address char * data; / * start of rmgr data to include * / / rmgr data size uint32 len / * length of rmgr data to include * /} XLogRecData

Registered_buffer

For each data block registered with XLogRegisterBuffer, populate it into the registered_buffer structure

/ * * For each block reference registered with XLogRegisterBuffer, we fill in * a registered_buffer struct. * for every data block registered with XLogRegisterBuffer, * populated into the registered_buffer structure * / typedef struct {/ / slot is in use? Bool in_use; / * is this slot in use? * / / REGBUF_* related tags uint8 flags; / * REGBUF_* flags * / / define identifiers for relationships and databases RelFileNode rnode; / * identifies the relation and block * / fork process number ForkNumber forkno; / / block number BlockNumber block / / Page content Page page; / * page content * / / Total data size in the rdata chain uint32 rdata_len; / * total length of data in rdata chain * / data link header XLogRecData * rdata_head registered with this data block / * head of the chain of data registered with * this block * / / XLogRecData * rdata_tail; / * last entry in the chain, or & rdata_head if * empty * / / temporary rdatas data reference registered with this data block, used to store backup block data XLogRecData bkp_rdatas used in XLogRecordAssemble () [2] / * temporary rdatas used to hold references to * backup block data in XLogRecordAssemble () * / / * buffer to store a compressed version of backup block image * / / the cache char compressed_ page used to store the compressed version of the backup block image [PGLZ _ MAX_BLCKSZ];} registered_buffer;//registered_buffer pointer (global variable) static registered_buffer * registered_buffers / / assigned size static int max_registered_buffers; / * allocated size * / / maximum block number + 1 (currently registered block) static int max_registered_block_id = 0; / * highest block_id + 1 currently * registered * / II. Source code interpretation

The XLogRecordAssemble function assembles the XLOG record from the registered data and buffer into the XLogRecData chain, and after assembly, it can be inserted into the WAL buffer using the XLogInsertRecord () function.

/ * Assemble a WAL record from the registered data and buffers into an * XLogRecData chain, ready for insertion with XLogInsertRecord (). * assemble XLOG record from registered data and buffers into XLogRecData chain, * insert it using the XLogInsertRecord () function after assembly. * The record header fields are filled in, except for the xl_prev field. The * calculated CRC does not include the record header yet. * except for xl_prev, the header field of XLOG Record has been populated. * the calculated CRC does not contain header information. * * If there are any registered buffers, and a full-page image was not taken * of all of them, * fpw_lsn is set to the lowest LSN among such pages. This * signals that the assembled record is only good for insertion on the * assumption that the RedoRecPtr and doPageWrites values were up-to-date. * if there is a registered buffer and full-page-image does not include all of this data, * * fpw_lsn is set to the smallest LSN in these pages. * based on the assumption that RedoRecPtr and doPageWrites have been updated, * the insertion of assembled XLOG Record on this assumption is OK. * / static XLogRecData * XLogRecordAssemble (RmgrId rmid, uint8 info, XLogRecPtr RedoRecPtr, bool doPageWrites, XLogRecPtr * fpw_lsn) {XLogRecData * rdt;//XLogRecData pointer uint32 total_len = 0 the XLOG Record size int block_id;// block ID pg_crc32c rdata_crc;//CRC registered_buffer * prev_regbuf = NULL / / registered buffer pointer XLogRecData * rdt_datas_last;// XLogRecord * rechdr;// header information char * scratch = hdr_scratch; / * * Note: this function can be called multiple times for the same record. * All the modifications we do to the rdata chains below must handle that. * for the same XLOG Record, this function can be called multiple times. * all the updates we make to the rdata chain below must handle this situation. The head size of * / * The record begins with the fixed-size header * / / XLOG Record is fixed. Rechdr = (XLogRecord *) scratch; scratch + = SizeOfXLogRecord;// pointer moves hdr_rdt.next = NULL;//hdr_rdt-- > static XLogRecData hdr_rdt; rdt_datas_last = & hdr_rdt;// hdr_rdt.data = start offset of hdr_scratch;//rmgr data / * * Enforce consistency checks for this record if user is looking for it. * Do this before at the beginning of this routine to give the possibility * for callers of XLogInsert () to pass XLR_CHECK_CONSISTENCY directly for * a record. * if you are searching for this record, force to check the consistency of the record. * perform this process before the start of the process so that the caller of XLogInsert () can pass the XLR_CHECK_CONSISTENCY directly to XLOG Record. * / if (wal_consistency_ checking [RMID]) info | = XLR_CHECK_CONSISTENCY; / * * Make an rdata chain containing all the data portions of all block * references. This includes the data for full-page images. Also append * the headers for the block references in the scratch buffer. * construct a rdata chain that holds the data portion of all block references. This includes FPI data. * at the same time, append header information to all block references in the scratch buffer. * / * fpw_lsn = InvalidXLogRecPtr;// initialization variable for (block_id = 0; block_id)

< max_registered_block_id; block_id++)//遍历已注册的block { registered_buffer *regbuf = ®istered_buffers[block_id];//获取根据block_id获取缓冲区 bool needs_backup;//是否需要backup block bool needs_data;//是否需要data XLogRecordBlockHeader bkpb;//XLogRecordBlockHeader XLogRecordBlockImageHeader bimg;//XLogRecordBlockImageHeader XLogRecordBlockCompressHeader cbimg = {0};//压缩存储时需要 bool samerel;//是否同一个rel? bool is_compressed = false;//是否压缩 bool include_image;//是否包括FPI if (!regbuf->

In_use) / / not in use, proceed to the next continue; / * Determine if this block needs to be backed up * / to determine whether this block requires backup if (regbuf- > flags & REGBUF_FORCE_IMAGE) needs_backup = true;// to force FPI else if (regbuf- > flags & REGBUF_NO_IMAGE) needs_backup = false / / it is mandatory that the IMAGE else if (! doPageWrites) needs_backup = false;//doPageWrites flag is set to F else//doPageWrites = T {/ * We assume page LSN is first data on * every* page that can be * passed to XLogInsert, whether it has the standard page layout * or not. * regardless of whether the page is standard page layout or not, * We assume that the first data in each page is page LSN, * * / XLogRecPtr page_lsn = PageGetLSN (regbuf- > page); / / get LSN needs_backup = (page_lsn rdata_len = = 0) / / No data needs_data = false Else if ((regbuf- > flags & REGBUF_KEEP_DATA)! = 0) / / needs to include data needs_data = true; else needs_data =! needs_backup;//needs_backup take inverse / / BlockHeader setting value bkpb.id = block_id;// block ID bkpb.fork_flags = regbuf- > forkno;//forkno bkpb.data_length = 0 / / data length if ((regbuf- > flags & REGBUF_WILL_INIT) = = REGBUF_WILL_INIT) bkpb.fork_flags | = BKPBLOCK_WILL_INIT;// setting tag / * * If needs_backup is true or WAL checking is enabled for current * resource manager, log a full-page write for the current block. * if needs_backup is T, or WAL check for the current RM is enabled, * full-page-write for the current block is required * / / backup is required, or consistency check include_image = needs_backup is required | | (info & XLR_CHECK_CONSISTENCY)! = 0 If (include_image) {/ / contains the block image Page page = regbuf- > page;// to get the corresponding page uint16 compressed_len = 0 position The page needs to be backed up / compressed size / * * The page needs to be backed up, so calculate its hole length * size. * backup is required for page Calculate the free space size and offset * / if (regbuf- > flags & REGBUF_STANDARD) {/ / such as the standard REGBUF / * Assume we can omit data between pd_lower and pd_upper * / / assume we can omit the data between pd_lower and pd_upper Uint16 lower = ((PageHeader) page)-> pd_lower / / get lower uint16 upper = ((PageHeader) page)-> pd_upper / / get upper if (lower > = SizeOfPageHeaderData & & upper > lower & & upper 0) / / main data size > 0 {if (mainrdata_len > 255) / / if it exceeds 255, the Long format {* (scratch++) = (char) XLR_BLOCK_ID_DATA_LONG is used. Memcpy (scratch, & mainrdata_len, sizeof (uint32)); scratch+ = sizeof (uint32);} else// otherwise use the Short format {* (scratch++) = (char) XLR_BLOCK_ID_DATA_SHORT; * (scratch++) = (uint8) mainrdata_len;} rdt_datas_last- > next = mainrdata_head Rdt_datas_last = mainrdata_last; total_len + = mainrdata_len;} rdt_datas_last- > next = NULL; hdr_rdt.len = (scratch-hdr_scratch); / / header size total_len + = hdr_rdt.len / / Total size / * * Calculate CRC of the data * CRC * * Note that the record header isn't added into the CRC initially since we * don't know the prev-link yet of the calculated data. Thus, the CRC will represent the CRC of * the whole record in the order: rdata, then backup blocks, then record * header. * since we don't know the value of prev-link, the header is not in the original CRC. * therefore, CRC will represent the CRC of the entire record in the following order: rdata, then backup blocks, then record header. * / INIT_CRC32C (rdata_crc); COMP_CRC32C (rdata_crc, hdr_scratch + SizeOfXLogRecord, hdr_rdt.len-SizeOfXLogRecord); for (rdt = hdr_rdt.next; rdt! = NULL; rdt = rdt- > next) COMP_CRC32C (rdata_crc, rdt- > data, rdt- > len); / * Fill in the fields in the record header. Prev-link is filled in later, * once we know where in the WAL the record will be inserted. The CRC does * not include the record header yet. * fill in other fields for recording header information. * Prev-link will populate when the record is inserted. * CRC does not include recorded header information. * / rechdr- > xl_xid = GetCurrentTransactionIdIfAny (); rechdr- > xl_tot_len = total_len; rechdr- > xl_info = info; rechdr- > xl_rmid = rmid; rechdr- > xl_prev = InvalidXLogRecPtr; rechdr- > xl_crc = rdata_crc; return & hdr_rdt;} III. Tracking analysis

Scenario 1: after clearing the data, insert for the first time after performing checkpoint

The test script is as follows:

Testdb=# truncate table tactile walkpoint partitionalism truncate TABLEtestdb=# checkpoint;CHECKPOINTtestdb=# insert into t_wal_partition (c1rect c2Magnec c3) VALUES (1reparentional checkpointwriting playbook checkpoint`)

Set breakpoint and enter XLogRecordAssemble

(gdb) b XLogRecordAssembleBreakpoint 1 at 0x565411: file xloginsert.c, line 488. (gdb) cContinuing.Breakpoint 1, XLogRecordAssemble (rmid=10'\ n, info=128'\ 200, RedoRecPtr=5507633240, doPageWrites=true, fpw_lsn=0x7fff05cfe378) at xloginsert.c:488488 uint32 total_len = 0

Enter parameters:

Rmid=10 is 0x0A-- > Heap

RedoRecPtr=5507633240

DoPageWrites=true, need full-page-write

Fpw_lsn=0x7fff05cfe378

Then there is variable assignment.

Where hdr_scratch is defined as: static char * hdr_scratch = NULL

Hdr_rdt is defined as: static XLogRecData hdr_rdt

(gdb) n491 registered_buffer * prev_regbuf = NULL; (gdb) 494 char * scratch = hdr_scratch; (gdb) 502 rechdr = (XLogRecord *) scratch; (gdb) 503 scratch + = SizeOfXLogRecord; (gdb)

Header information of XLOG Record

(gdb) p * (XLogRecord *) rechdr$11 = {xl_tot_len = 14, xl_xid = 1997, xl_prev = 5507669824, xl_info = 128'\ 200, xl_rmid = 1'\ 001, xl_crc = 3794462175}

The scratch pointer points to the address after Header

(gdb) p hdr_scratch$12 = 0x18a24c0 "r"

Assign a value to the global variable hdr_rdt

505 hdr_rdt.next = NULL; (gdb) 506 rdt_datas_last = & hdr_rdt; (gdb) 507 hdr_rdt.data = hdr_scratch; (gdb) p hdr_rdt$5 = {next = 0x0, data = 0x18a24c0 "r", len = 26} (gdb) p * (XLogRecord *) hdr_rdt.data$7 = {xl_tot_len = 114, xl_xid = 1997, xl_prev = 5507669824, xl_info = 128'\ 200, xl_rmid = 1'\ 001, xl_crc = 3794462175}

Do not perform a consistency check

(gdb) n515 if (wal_consistency_ checking [rmid]) (gdb) 523 * fpw_lsn = InvalidXLogRecPtr; (gdb)

Initialize the fpw_lsn and start the loop.

There are only 1 registered block id.

(gdb) n524 for (block_id = 0; block_id)

< max_registered_block_id; block_id++)(gdb) p max_registered_block_id$13 = 1 获取已注册的buffer. 其中: rnode->

RelFilenode structure, spcNode- > tablespace / dbNode- > database / relNode- > relationship

Block- > Block ID

Page- > data page pointer (char *)

Total data size in the rdata_len- > rdata chain

Rdata_head- > data link headers registered with this data block

Rdata_tail- > the tail of the data chain registered with this data block

Bkp_rdatas- > temporary rdatas data reference for storing backup block data used in XLogRecordAssemble ().

Bkp_rdatas is used to assemble block image,bkp_rdatas [0] to store data before free space (hole), and bkp_rdatas [1] to store data after free space.

(gdb) n526 registered_buffer * regbuf = & registered_ buffers [block _ id]; (gdb) 531 XLogRecordBlockCompressHeader cbimg = {0} (gdb) p * regbuf$14 = {in_use = true, flags = 14'\ 016, rnode = {spcNode = 1663, dbNode = 16402, relNode = 25258}, forkno = MAIN_FORKNUM, block = 0, page = 0x7fb8539e7380 "", rdata_len = 32, rdata_head = 0x18a22c0, rdata_tail = 0x18a22d8, bkp_rdatas = {next = 0x18a4230, data = 0x7fb85390f380 "\ 001", len = 252}, {next = 0x18a22a8, data = 0x7fb85390fe28 "\ 315\ a", len = 5464}} Compressed_page ='\ 000'}

Note:

In memory, main data is registered by the function XLogRegisterData and maintained by mainrdata_head and mainrdata_last pointers. In this case, the xl_heap_insert structure is populated.

Block data is initialized by XLogRegisterBuffer, and data is populated by XLogRegisterBufData. In this case, the data is registered twice through XLogRegisterBufData, the first is the xl_heap_header structure, and the second is the actual data (essentially just a data pointer, and it is up to the assembler to determine what data is ultimately needed).

(gdb) p * mainrdata_head$18 = {next = 0x18a22c0, data = 0x7fff05cfe3f0 "\ 001", len = 3} (gdb) p * (xl_heap_insert *) mainrdata_head- > data$20 = {offnum = 1, flags = 0'\ 000'} (gdb) p * regbuf- > rdata_head$32 = {next = 0x18a22d8, data = 0x7fff05cfe3e0 "\ 003", len = 5} (gdb) p * (xl_heap_header *) regbuf- > rdata_head- > data$28 = {t_infomask2 = 3, t_infomask = 2050 T_hoff = 24'\ 030'} (gdb) p * regbuf- > rdata_head- > next$34 = {next = 0x18a22f0, data = 0x18edaef "", len = 27}

Displays 27 bytes after the address 0x18edaef in character format (tuple data)

(gdb) x/27bc 0x18edaef0x18edaef: 0'\ 0001'\ 001' 0'\ 000' 0'\ 000' 23'\ 027' 99'c' 104 'h'0x18edaf7: 101' e' 99'c' 107'k' 112'p' 111 'o105' i110'n '116' t'0x18edaff: 23'\ 027' 99'c '104' h101'e' 99c' 107k112 p11111o'0x18edb07: 105i 110n116t'

Continue to execute, since this record is the first record, there is no need to execute full-page-image

(gdb) n533 bool is_compressed = false; (gdb) 536 if (! regbuf- > in_use) (gdb) 540 if (regbuf- > flags & REGBUF_FORCE_IMAGE) (gdb) p regbuf- > flags$36 = 14'\ 016'(gdb) n542 else if (regbuf- > flags & REGBUF_NO_IMAGE) (gdb) 543 needs_backup = false

Needs_data is T and only tuple data is written to the transaction log

(gdb) n564 if (regbuf- > rdata_len = = 0) (gdb) p regbuf- > rdata_len$37 = 32 (gdb) n566 else if ((regbuf- > flags & REGBUF_KEEP_DATA)! = 0) (gdb) 569 needs_data =! needs_backup; (gdb) 571 bkpb.id = block_id; (gdb) p needs_data$38 = true

Set the value of the XLogRecordBlockHeader field, the first tuple in page, and the flag is set to BKPBLOCK_WILL_INIT

(gdb) n572 bkpb.fork_flags = regbuf- > forkno; (gdb) 573 bkpb.data_length = 0; (gdb) 575 if ((regbuf- > flags & REGBUF_WILL_INIT) = = REGBUF_WILL_INIT) (gdb) n576 bkpb.fork_flags | = BKPBLOCK_WILL_INIT; (gdb) 582 include_image = needs_backup | | (info & XLR_CHECK_CONSISTENCY)! = 0 (gdb) p bkpb$40 = {id = 0'\ 000mm, fork_flags = 64'@', data_length = 0} (gdb)

No need to execute FPI

(gdb) p info$41 = 128'\ 200'(gdb) n584 if (include_image) (gdb) p include_image$42 = false (gdb)

Need to include data

(gdb) n691 if (needs_data) (gdb) 697 bkpb.fork_flags | = BKPBLOCK_HAS_DATA; (gdb) 698 bkpb.data_length = regbuf- > rdata_len; (gdb) 699 total_len + = regbuf- > rdata_len; (gdb) 701 rdt_datas_last- > next = regbuf- > rdata_head; (gdb) 702 rdt_datas_last = regbuf- > rdata_tail (gdb) p bkpb$43 = {id = 0'\ 000mm, fork_flags = 96'`, data_length = 32} (gdb) p total_len$44 = 32 (gdb) p * rdt_datas_last$45 = {next = 0x18a22c0, data = 0x18a24c0 "r", len = 26}

OK, copy the header information to the scratch buffer

(gdb) n705 if (prev_regbuf & & RelFileNodeEquals (regbuf- > rnode, prev_regbuf- > rnode)) (gdb) p prev_regbuf$46 = (registered_buffer *) 0x0 (gdb) n711 samerel = false; (gdb) 712 prev_regbuf = regbuf; (gdb) 715 memcpy (scratch, & bkpb, SizeOfXLogRecordBlockHeader)

Followed by RefFileNode + BlockNumber

(gdb) 716 scratch + = SizeOfXLogRecordBlockHeader; (gdb) 717 if (include_image) (gdb) 728 if (! samerel) (gdb) 730 memcpy (scratch, & regbuf- > rnode, sizeof (RelFileNode)); (gdb) 731 scratch + = sizeof (RelFileNode); (gdb) 733 memcpy (scratch, & regbuf- > block, sizeof (BlockNumber)); (gdb) 734 scratch + = sizeof (BlockNumber) (gdb) 524 for (block_id = 0; block_id)

< max_registered_block_id; block_id++) 结束循环 524 for (block_id = 0; block_id < max_registered_block_id; block_id++)(gdb) 接下来是replorigin_session_origin(实际并不需要) 738 if ((curinsert_flags & XLOG_INCLUDE_ORIGIN) &&(gdb) p curinsert_flags$47 = 1 '\001'(gdb) $48 = 1 '\001'(gdb) n739 replorigin_session_origin != InvalidRepOriginId)(gdb) 738 if ((curinsert_flags & XLOG_INCLUDE_ORIGIN) && 接下来是main data (gdb) 747 if (mainrdata_len >

0) (gdb) 749 if (mainrdata_len > 25551) (gdb) 757 * (scratch++) = (char) XLR_BLOCK_ID_DATA_SHORT; (gdb) (gdb) 758 * (scratch++) = (uint8) mainrdata_len; (gdb) 760 rdt_datas_last- > next = mainrdata_head; (gdb) 761 rdt_datas_last = mainrdata_last; (gdb) 762total_len + = mainrdata_len; (gdb)

Calculated Siz

764 rdt_datas_last- > next = NULL; (gdb) 766 hdr_rdt.len = (scratch-hdr_scratch); (gdb) p scratch$49 = 0x18a24ee "" (gdb) p hdr_scratch$50 = 0x18a24c0 "r" (gdb) p hdr_rdt.len$51 = 26 (gdb) p total_len$52 = 35 (gdb) (gdb) n767 total_len + = hdr_rdt.len; (gdb)

Calculate CRC

(gdb) 777 INIT_CRC32C (rdata_crc); (gdb) 778 COMP_CRC32C (rdata_crc, hdr_scratch + SizeOfXLogRecord, hdr_rdt.len-SizeOfXLogRecord); (gdb) 779 for (rdt = hdr_rdt.next; rdt! = NULL; rdt = rdt- > next) (gdb) n780 COMP_CRC32C (rdata_crc, rdt- > data, rdt- > len); (gdb) 779 for (rdt = hdr_rdt.next; rdt! = NULL) Rdt = rdt- > next) (gdb) 780 COMP_CRC32C (rdata_crc, rdt- > data, rdt- > len); (gdb) 779 for (rdt = hdr_rdt.next; rdt! = NULL; rdt = rdt- > next) (gdb) 780 COMP_CRC32C (rdata_crc, rdt- > data, rdt- > len); (gdb) 779 for (rdt = hdr_rdt.next; rdt! = NULL; rdt = rdt- > next) (gdb) 787 rechdr- > xl_xid = GetCurrentTransactionIdIfAny ()

Fill in other fields of record header information.

(gdb) n788 rechdr- > xl_tot_len = total_len; (gdb) 789 rechdr- > xl_info = info; (gdb) 790 rechdr- > xl_rmid = rmid; (gdb) 791rechdr- > xl_prev = InvalidXLogRecPtr; (gdb) 792rechdr- > xl_crc = rdata_crc; (gdb) 794return & hdr_rdt (gdb) 795} (gdb) p rechdr$62 = (XLogRecord *) 0x18a24c0 (gdb) p * rechdr$63 = {xl_tot_len = 81, xl_xid = 1998, xl_prev = 0, xl_info = 128'\ 200, xl_rmid = 10'\ n, xl_crc = 1852971194} (gdb)

Follow-up analysis of full-page-write scene

IV. Reference materials

Write Ahead Logging-WAL

PostgreSQL Source Code interpretation (4)-insert data # 3 (heap_insert)

Analysis of WAL structure of PostgreSQL transaction Log

PG Source Code

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.