Shulou(Shulou.com)05/31 Report--

This article focuses on "what are the functions that heap_insert depends on in PostgreSQL". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Now let the editor take you to learn what are the functions that heap_insert depends on in PostgreSQL.

I. data structure

Static variable

Global sharing in process

/ * An array of XLogRecData structs, to hold registered data. * XLogRecData structure array to store registered data * / static XLogRecData * entry static int num_rdatas; / * entries currently used * / / allocated space size static int max_rdatas; / * allocated size * / / whether to call the XLogBeginInsert function static bool begininsert_called = false

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 corrects the size static int max_registered_buffers allocated by static registered_buffer * registered_buffers;// / * allocated size * / / maximum block number + 1 (currently registered block) static int max_registered_block_id = 0; / * highest block_id + 1 currently * registered * /

XLogCtlInsert

Shared data structure used by WAL when inserting records

/ * Shared state data for WAL insertion. * shared data structure used by WAL when inserting records * / typedef struct XLogCtlInsert {/ / lock slock_t insertpos_lck; / * protects CurrBytePos and PrevBytePos * / * * CurrBytePos is the end of reserved WAL containing CurrBytePos and PrevBytePos. The next record will be * inserted at that position. PrevBytePos is the start position of the * previously inserted (or rather, reserved) record-it is copied to the * prev-link of the next record. These are stored as "usable byte * positions" rather than XLogRecPtrs (see XLogBytePosToRecPtr ()). * CurrBytePos is the end position where WAL is reserved. * the next record will be inserted in that location. * PrevBytePos is the starting position where the record was previously inserted (or retained)-it is copied to the prev-link of the next record. * these stores are "available byte positions" rather than XLogRecPtrs (see XLogBytePosToRecPtr ()). * / uint64 CurrBytePos; uint64 PrevBytePos; / * * Make sure the above heavily-contended spinlock and byte positions are * on their own cache line. In particular, the RedoRecPtr and full page * write variables below should be on a different cache line. They are * read on every WAL insertion, but updated rarely, and we don't want * those reads to steal the cache line containing Curr/PrevBytePos. * make sure that the above highly competitive spin locks and byte positions are on their own cache line. * in particular, RedoRecPtr and the following full-page write variables should be on different cache line. * they are read every time the WAL is inserted, but are rarely updated. * We don't want these reads to steal the cache line that contains the Curr/PrevBytePos. * / char Pad [PG _ CACHE_LINE_SIZE]; / * fullPageWrites is the master copy used by all backends to determine * whether to write full-page to WAL, instead of using process-local one. * This is required because, when full_page_writes is changed by SIGHUP, * we must WAL-log it before it actually affects WAL-logging by backends. * Checkpointer sets at startup or after SIGHUP. * fullpagewrite is the master copy used by all background processes, and * is used to determine whether the entire page is written to WAL instead of using a process-local copy. This is necessary because when SIGHUP changes full_page_write, * we must WAL-log record it before it actually affects WAL-logging through the background process. * the Checkpointer checkpoint is set after startup or SIGHUP. * To read these fields, you must hold an insertion lock. To modify them, * you must hold ALL the locks. * in order to read these fields, you must hold insertion lock. * if you need to update, you need to hold all of these lock. * / the current redo point XLogRecPtr RedoRecPtr; / * current redo point for insertions * / / at the time of insertion forces full-page writing for PITR? Bool forcePageWrites; / * forcing full-page writes for PITR? * / is it full-page? Bool fullPageWrites; / * * exclusiveBackupState indicates the state of an exclusive backup (see * comments of ExclusiveBackupState for more details). NonExclusiveBackups * is a counter indicating the number of streaming base backups currently * in progress. ForcePageWrites is set to true when either of these is * non-zero. LastBackupStart is the latest checkpoint redo location used * as a starting point for an online backup. * exclusive sivebackupstate indicates the status of the exclusive backup * (see the notes for exclusive sivebackupstate for more information). * non-exclusive backups are a counter that indicates the number of stream-based backups currently in progress. * forcePageWrites is set to true at neither of these values at 00:00. * the redo location of the latest checkpoint where lastBackupStart is used as the starting point for online backups. * / ExclusiveBackupState exclusiveBackupState; int nonExclusiveBackups; XLogRecPtr lastBackupStart; / * * WAL insertion locks. * WAL write lock * / WALInsertLockPadded * WALInsertLocks;} XLogCtlInsert

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/registered_buffers

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

Heap_insert

The main implementation logic is to insert tuples into the heap, in which there is a part for processing WAL (XLog).

See PostgreSQL Source Code interpretation (104)-WAL#1 (Insert & WAL-heap_insert function # 1)

XLogBeginInsert

Start constructing WAL records.

Must be called before calling the XLogRegister* and XLogInsert () functions.

/ * Begin constructing a WAL record. This must be called before the * XLogRegister* functions and XLogInsert (). * start constructing WAL records. * must be called before calling the XLogRegister* and XLogInsert () functions. * / voidXLogBeginInsert (void) {/ / Verification logic Assert (max_registered_block_id = = 0); Assert (mainrdata_last = = (XLogRecData *) & mainrdata_head); Assert (mainrdata_len = = 0); / * cross-check on whether we should be here or not * / / Cross-check whether if (! XLogInsertAllowed () elog (ERROR, "cannot make new WAL entries during recovery") should or should not appear here If (begininsert_called) elog (ERROR, "XLogBeginInsert was already called"); / / variable assignment begininsert_called = true;} / * * Is this process allowed to insert new WAL records? * determine whether the process allows the insertion of new WAL records * * Ordinarily this is essentially equivalent to! RecoveryInProgress (). * But we also have provisions for forcing the result "true" or "false" * within specific processes regardless of the global state. * usually, this is essentially equivalent to! Recoverinprogress (). * but we also have rules that force "right" or "wrong" results in a particular process, regardless of the overall situation. * / boolXLogInsertAllowed (void) {/ * If value is "unconditionally true" or "unconditionally false", just * return it. This provides the normal fast path once recovery is known * done. * returns if the value is "unconditionally true" or "unconditionally false". * this provides a normal quick judgment path. * / if (LocalXLogInsertAllowed > = 0) return (bool) LocalXLogInsertAllowed; / * Else, must check to see if we're still in recovery. * otherwise, you must check whether it is restored * / if (RecoveryInProgress ()) return false; / * * On exit from recovery, reset to "unconditionally true", since there is * no need to keep checking. * withdraw from recovery and reset to "unconditionally true" because no further check is required * / LocalXLogInsertAllowed = 1; return true;}

XLogRegisterData

Add data to the WAL record being constructed

/ * Add data to the WAL record that's being constructed. * add data to the WAL record being constructed * * The data is appended to the "main chunk", available at replay with * XLogRecGetData (). * data is appended to "main chunk" for XLogRecGetData () function playback * / voidXLogRegisterData (char * data, int len) {XLogRecData * rdata;// data / / verify whether begin Assert (begininsert_called) has been called; / / verify size if (num_rdatas > = max_rdatas) elog (ERROR, "too much WAL data"); rdata = & rdatasnum _ rdatas++; rdata- > data = data; rdata- > len = len / * we use the mainrdata_last pointer to track the end of the chain, so no * need to clear 'next' here. * use the mainrdata_last pointer to track the end of the chain, where there is no need to clear the next variable * / mainrdata_last- > next = rdata; mainrdata_last = rdata; mainrdata_len + = len;}

XLogRegisterBuffer

Register the dependency of the built WAL record in the buffer, which must be called when each page is updated by the WAL-logged operation

/ * Register a reference to a buffer with the WAL record being constructed. * This must be called for every page that the WAL-logged operation modifies. * register the dependency of the built WAL record in the buffer * this function must be called when updating each page in the WAL-logged operation * / voidXLogRegisterBuffer (uint8 block_id, Buffer buffer, uint8 flags) {registered_buffer * regbuf / / buffer / * NO_IMAGE doesn't make sense with FORCE_IMAGE * / / NO_IMAGE cannot use Assert (! ((flags & REGBUF_FORCE_IMAGE) & & (flags & (REGBUF_NO_IMAGE) with REGBUF_NO_IMAGE at the same time; Assert (begininsert_called) / / Block ID > maximum registered buffer, error if (block_id > = max_registered_block_id) {if (block_id > = max_registered_buffers) elog (ERROR, "too many registered buffers"); max_registered_block_id = block_id + 1;} / / assign regbuf = & registered_ buffers [block _ id] / / get Tag BufferGetTag (buffer, & regbuf- > rnode, & regbuf- > forkno, & regbuf- > block); regbuf- > page = BufferGetPage (buffer); regbuf- > flags = flags; regbuf- > rdata_tail = (XLogRecData *) & regbuf- > rdata_head; regbuf- > rdata_len = 0; / * Check that this page hasn't already been registered with some other * block_id. * check whether the page has been registered by another block_id * / # ifdef USE_ASSERT_CHECKING {int i; for (I = 0; I

< max_registered_block_id; i++)//循环检查 { registered_buffer *regbuf_old = ®istered_buffers[i]; if (i == block_id || !regbuf_old->

In_use) continue; Assert (! RelFileNodeEquals (regbuf_old- > rnode, regbuf- > rnode) | | regbuf_old- > forkno! = regbuf- > forkno | | regbuf_old- > block! = regbuf- > block);}} # endif regbuf- > in_use = true;// marked with} / * * BufferGetTag * Returns the relfilenode, fork number and block number associated with * a buffer. * return the relfilenode,fork number and block number associated with the buffer * / voidBufferGetTag (Buffer buffer, RelFileNode * rnode, ForkNumber * forknum, BlockNumber * blknum) {BufferDesc * bufHdr; / * Do the same checks as BufferGetBlockNumber. * / / verify that buffer has been pinned Assert (BufferIsPinned (buffer)); if (BufferIsLocal (buffer)) bufHdr = GetLocalBufferDescriptor (- buffer-1); else bufHdr = GetBufferDescriptor (buffer-1); / * pinned, so OK to read tag without spinlock * / / pinned, there is no need for spinlock to read tage * rnode = bufHdr- > tag.rnode; * forknum = bufHdr- > tag.forkNum; * blknum = bufHdr- > tag.blockNum } / * * BufferIsLocal * True iff the buffer is local (not visible to other backends). * Local buffer * / # define BufferIsLocal (buffer) ((buffer) if the buffer is not invisible to other background processes

< 0)#define GetBufferDescriptor(id) (&BufferDescriptors[(id)].bufferdesc)#define GetLocalBufferDescriptor(id) (&LocalBufferDescriptors[(id)])BufferDesc *LocalBufferDescriptors = NULL;BufferDescPadded *BufferDescriptors; XLogRegisterBufData 在正在构造的WAL记录中添加buffer相关的数据. /* * Add buffer-specific data to the WAL record that's being constructed. * 在正在构造的WAL记录中添加buffer相关的数据. * * Block_id must reference a block previously registered with * XLogRegisterBuffer(). If this is called more than once for the same * block_id, the data is appended. * Block_id必须引用先前注册到XLogRegisterBuffer()中的数据块。 * 如果对同一个block_id不止一次调用，那么数据将会追加。 * * The maximum amount of data that can be registered per block is 65535 * bytes. That should be plenty; if you need more than BLCKSZ bytes to * reconstruct the changes to the page, you might as well just log a full * copy of it. (the "main data" that's not associated with a block is not * limited) * 每个块可注册的最大大小是65535Bytes. * 通常来说这已经足够了;如果需要大小比BLCKSZ字节更大的数据用于重建页面的变化, * 那么需要整页进行拷贝. * (与数据块相关的"main data"是不受限的) */voidXLogRegisterBufData(uint8 block_id, char *data, int len){ registered_buffer *regbuf;//注册的缓冲区 XLogRecData *rdata;//数据 Assert(begininsert_called);//XLogBeginInsert函数已调用 /* find the registered buffer struct */ //寻找已注册的缓存结构体 regbuf = ®istered_buffers[block_id]; if (!regbuf->

In_use) elog (ERROR, "no block with id% d registered with WAL insertion", block_id); if (num_rdatas > = max_rdatas) elog (ERROR, "too much WAL data"); rdata = & r dataset [num _ rdatas++]; rdata- > data = data; rdata- > len = len; regbuf- > rdata_tail- > next = rdata; regbuf- > rdata_tail = rdata; regbuf- > rdata_len + = len;}

XLogSetRecordFlags

Set the insert status flag for the upcoming "coming" WAL record

XLOG_INCLUDE_ORIGIN determines whether the starting point of replication should be included in the record

XLOG_MARK_UNIMPORTANT says records are not important for persistence, which avoids triggering WAL archives and other background activities

/ * Set insert status flags for the upcoming WAL record. * set the insertion status tag for the upcoming WAL record * * The flags that can be used here are: *-XLOG_INCLUDE_ORIGIN, to determine if the replication origin should be * included in the record. *-XLOG_MARK_UNIMPORTANT, to signal that the record is not important for * durability, which allows to avoid triggering WAL archiving and other * background activity. * the flag is used for: *-XLOG_INCLUDE_ORIGIN to determine whether the starting point of replication should be included in the record *-XLOG_MARK_UNIMPORTANT indicates that the record is not important for persistence, which avoids triggering WAL archiving and other background activities. * / voidXLogSetRecordFlags (uint8 flags) {Assert (begininsert_called); curinsert_flags = flags;} 3. Tracking analysis

The test script is as follows

Insert into t_wal_partition (C1, c2, c3) VALUES (0, HASH0, HASH0, HAHS0')

XLogBeginInsert

Start gdb, set breakpoints, and enter XLogBeginInsert

(gdb) b XLogBeginInsertBreakpoint 1 at 0x564897: file xloginsert.c, line 122. (gdb) cContinuing.Breakpoint 1, XLogBeginInsert () at xloginsert.c:122122 Assert (max_registered_block_id = = 0)

Check, call XLogInsertAllowed

122 Assert (max_registered_block_id = 0); (gdb) n123 Assert (mainrdata_last = = (XLogRecData *) & mainrdata_head); (gdb) 124 Assert (mainrdata_len = 0); (gdb) 127 if (! XLogInsertAllowed ()) (gdb) stepXLogInsertAllowed () at xlog.c:81268126 if (LocalXLogInsertAllowed > = 0) (gdb) n8132 if (RecoveryInProgress ()) (gdb) 8139 LocalXLogInsertAllowed = 1; (gdb) 8140 return true; (gdb) 8141} (gdb)

Assign, set begininsert_called to T, and return

(gdb) XLogBeginInsert () at xloginsert.c:130130 if (begininsert_called) (gdb) p begininsert_called$1 = false (gdb) n133 begininsert_called = true; (gdb) 134} (gdb) heap_insert (relation=0x7f5cc0338228, tup=0x29b2440, cid=0, options=0, bistate=0x0) at heapam.c:25672567 XLogRegisterData ((char *) & xlrec, SizeOfHeapInsert); (gdb)

XLogRegisterData

Enter the XLogRegisterData function

(gdb) stepXLogRegisterData (data=0x7fff03ba99e0 "\ 002", len=3) at xloginsert.c:327327 Assert (begininsert_called); (gdb) p * data$2 = 2'\ 002' (gdb) p * (xl_heap_insert *) data$3 = {offnum = 2, flags = 0'\ 000'}

Execute relevant judgments and assign values

Rdatas is the pointer to the XLogRecData structure, and the global static variable:

Static XLogRecData * rdatas

(gdb) n329 if (num_rdatas > = max_rdatas) (gdb) p num_rdatas$4 = 0 (gdb) p max_rdatas$5 = 20 (gdb) n331 rdata = & rdataset [num _ rdatas++]; (gdb) p rdatas [0] $6 = {next = 0x0, data = 0x0, len = 0} (gdb) p rdatas [1] $7 = {next = 0x0, data = 0x0, len = 0}

Related structure body assignment

Where mainrdata_last is the address of mainrdata_head:

Static XLogRecData * mainrdata_head

Static XLogRecData * mainrdata_last = (XLogRecData *) & mainrdata_head

(gdb) n333 rdata- > data = data; (gdb) 334 rdata- > len = len; (gdb) 341 mainrdata_last- > next = rdata; (gdb) 342 mainrdata_last = rdata; (gdb) 344 mainrdata_len + = len; (gdb) 345}

Complete the call and go back to heap_insert

(gdb) nheap_insert (relation=0x7f5cc0338228, tup=0x29b2440, cid=0, options=0, bistate=0x0) at heapam.c:25692569 xlhdr.t_infomask2 = heaptup- > tasking data-> t_infomask2

XLogRegisterBuffer

Enter XLogRegisterBuffer

(gdb) stepXLogRegisterBuffer (block_id=0'\ 000mm, buffer=99, flags=8'\ b') at xloginsert.c:218218 Assert (! ((flags & REGBUF_FORCE_IMAGE) & & (flags & (REGBUF_NO_IMAGE)

Judge block_id, set max_registered_block_id variable, etc.

Note: max_registered_buffers is initialized to 5

(gdb) n219 Assert (begininsert_called); (gdb) 221 if (block_id > = max_registered_block_id) (gdb) p max_registered_block_id$14 = 0 (gdb) n223 if (block_id > = max_registered_buffers) (gdb) p max_registered_buffers$15 = 5 (gdb) n225 max_registered_block_id = block_id + 1; (gdb) 228 regbuf = & registered_ buffers [block _ id] (gdb) p max_registered_buffers$16 = 5 (gdb) p max_registered_block_id$17 = 1 (gdb) n230 BufferGetTag (buffer, & regbuf- > rnode, & regbuf- > forkno, & regbuf- > block) (gdb) p * regbuf$18 = {in_use = false, flags = 0000, rnode = {spcNode = 0, dbNode = 0, relNode = 0}, forkno = MAIN_FORKNUM, block = 0, page = 0x0, rdata_len = 0, rdata_head = 0x0, rdata_tail = 0x0, bkp_rdatas = {next = 0x0, data = 0x0, len = 0}, {next = 0x0, data = 0x0, len = 0}, compressed_page ='\ 000'}

Get the tag of buffer

Rnode/forkno/block

(gdb) n231 regbuf- > page = BufferGetPage (buffer) (gdb) p * regbuf$19 = {in_use = false, flags = 0'\ 000mm, rnode = {spcNode = 1663, dbNode = 16402, relNode = 17034}, forkno = MAIN_FORKNUM, block = 0, page = 0x0, rdata_len = 0, rdata_head = 0x0, rdata_tail = 0x0, bkp_rdatas = {next = 0x0, data = 0x0, len = 0}, {next = 0x0, data = 0x0, len = 0}, compressed_page ='\ 000'}

Set other variables such as flags

(gdb) n232 regbuf- > flags = flags; (gdb) 233 regbuf- > rdata_tail = (XLogRecData *) & regbuf- > rdata_head; (gdb) 234 regbuf- > rdata_len = 0; (gdb) 244 for (I = 0; I

< max_registered_block_id; i++)(gdb) p regbuf->

Flags$21 = 8'\ b' (gdb) p * regbuf- > rdata_tail$23 = {next = 0x0, data = 0x292e1a8 "", len = 0} (gdb) p regbuf- > rdata_len$24 = 0

Check whether the page has been registered by another block_id

Finally, set in_use to T and return XLogRegisterBufData

(gdb) n246 registered_buffer * regbuf_old = & registered_buffers [I]; (gdb) 248 if (I = = block_id | |! regbuf_old- > in_use) (gdb) 249 continue; (gdb) 244 for (I = 0; I

< max_registered_block_id; i++)(gdb) 258 regbuf->

In_use = true; (gdb) 259} (gdb) heap_insert (relation=0x7f5cc0338228, tup=0x29b2440, cid=0, options=0, bistate=0x0) at heapam.c:25792579 XLogRegisterBufData (0, (char *) & xlhdr, SizeOfHeapHeader)

XLogRegisterBufData

Enter the XLogRegisterBufData function

(gdb) stepXLogRegisterBufData (block_id=0'\ 000000, data=0x7fff03ba99d0 "\ 003", len=5) at xloginsert.c:366366 Assert (begininsert_called)

Find a registered cache structure

(gdb) n369 regbuf = & registered_ buffers [block _ id] (gdb) 370 if (! regbuf- > in_use) (gdb) p * regbuf$25 = {in_use = true, flags = 8'\ baked, rnode = {spcNode = 1663, dbNode = 16402, relNode = 17034}, forkno = MAIN_FORKNUM, block = 0, page = 0x7f5c93854380 "\ 001", rdata_len = 0, rdata_head = 0x0, rdata_tail = 0x292e1a8, bkp_rdatas = {{next = 0x0, data = 0x0, len = 0}, {next = 0x0, data = 0x0, len = 0}} Compressed_page ='\ 000'} (gdb) p * regbuf- > page$26 = 1'\ 001' (gdb) n374 if (num_rdatas > = max_rdatas) (gdb)

Add buffer related data to the WAL record being constructed.

(gdb) n376 rdata = & rdatasa [num _ rdatas++]; (gdb) p num_rdatas$27 = 1 (gdb) p max_rdatas$28 = 20 (gdb) n378 rdata- > data = data; (gdb) 379 rdata- > len = len; (gdb) 381 regbuf- > rdata_tail- > next = rdata; (gdb) 382regbuf- > rdata_tail = rdata; (gdb) 383regbuf- > rdata_len + = len (gdb) 384} (gdb) p * rdata$29 = {next = 0x0, data = 0x7fff03ba99d0 "\ 003", len = 5} (gdb)

Complete the call and go back to heap_insert

(gdb) nheap_insert (relation=0x7f5cc0338228, tup=0x29b2440, cid=0, options=0, bistate=0x0) at heapam.c:25832583 heaptup- > t_len-SizeofHeapTupleHeader)

Continue to call the XLogRegisterBufData function to register the tuple actual data

2583 heaptup- > t_len-SizeofHeapTupleHeader); (gdb) n2581 XLogRegisterBufData (0, (gdb)

XLogSetRecordFlags

Set the insert status flag for the upcoming "coming" WAL record

(gdb) 2586 XLogSetRecordFlags (XLOG_INCLUDE_ORIGIN)

The logic is simple: set the tag bit curinsert_flags

(gdb) stepXLogSetRecordFlags (flags=1'\ 001') at xloginsert.c:399399 Assert (begininsert_called); (gdb) n400 curinsert_flags = flags; (gdb) 401} (gdb) heap_insert (relation=0x7f5cc0338228, tup=0x29b2440, cid=0, options=0, bistate=0x0) at heapam.c:25882588 recptr = XLogInsert (RM_HEAP_ID, info); (gdb)

Call XLogInsert and insert WAL

(gdb) 2590 PageSetLSN (page, recptr); At this point, I believe that you have a deeper understanding of the functions that heap_insert depends on in PostgreSQL, so you might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

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.