Baoding-FenShuaJiang
/
Green_GoodERP18_FSJ_Standard
Suivre 1
Ajouter aux favoris 0
Wiki 捐赠
gooderp18绿色标准版
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
Aborescence: 0f75e31513
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '0f75e31513'
${ noResults }
Green_GoodERP18_FSJ_Standard/PostgreSQL/include/server/replication/reorderbuffer.h

442 lignes
13KB
Brut Annotations Historique 

  1. /*

  2.  * reorderbuffer.h

  3.  *	  PostgreSQL logical replay/reorder buffer management.

  4.  *

  5.  * Copyright (c) 2012-2019, PostgreSQL Global Development Group

  6.  *

  7.  * src/include/replication/reorderbuffer.h

  8.  */

  9. #ifndef REORDERBUFFER_H

  10. #define REORDERBUFFER_H

  11. 

  12. #include "access/htup_details.h"

  13. #include "lib/ilist.h"

  14. #include "storage/sinval.h"

  15. #include "utils/hsearch.h"

  16. #include "utils/relcache.h"

  17. #include "utils/snapshot.h"

  18. #include "utils/timestamp.h"

  19. 

  20. /* an individual tuple, stored in one chunk of memory */

  21. typedef struct ReorderBufferTupleBuf

  22. {

  23. 	/* position in preallocated list */

  24. 	slist_node	node;

  25. 

  26. 	/* tuple header, the interesting bit for users of logical decoding */

  27. 	HeapTupleData tuple;

  28. 

  29. 	/* pre-allocated size of tuple buffer, different from tuple size */

  30. 	Size		alloc_tuple_size;

  31. 

  32. 	/* actual tuple data follows */

  33. } ReorderBufferTupleBuf;

  34. 

  35. /* pointer to the data stored in a TupleBuf */

  36. #define ReorderBufferTupleBufData(p) \

  37. 	((HeapTupleHeader) MAXALIGN(((char *) p) + sizeof(ReorderBufferTupleBuf)))

  38. 

  39. /*

  40.  * Types of the change passed to a 'change' callback.

  41.  *

  42.  * For efficiency and simplicity reasons we want to keep Snapshots, CommandIds

  43.  * and ComboCids in the same list with the user visible INSERT/UPDATE/DELETE

  44.  * changes. Users of the decoding facilities will never see changes with

  45.  * *_INTERNAL_* actions.

  46.  *

  47.  * The INTERNAL_SPEC_INSERT and INTERNAL_SPEC_CONFIRM changes concern

  48.  * "speculative insertions", and their confirmation respectively.  They're

  49.  * used by INSERT .. ON CONFLICT .. UPDATE.  Users of logical decoding don't

  50.  * have to care about these.

  51.  */

  52. enum ReorderBufferChangeType

  53. {

  54. 	REORDER_BUFFER_CHANGE_INSERT,

  55. 	REORDER_BUFFER_CHANGE_UPDATE,

  56. 	REORDER_BUFFER_CHANGE_DELETE,

  57. 	REORDER_BUFFER_CHANGE_MESSAGE,

  58. 	REORDER_BUFFER_CHANGE_INTERNAL_SNAPSHOT,

  59. 	REORDER_BUFFER_CHANGE_INTERNAL_COMMAND_ID,

  60. 	REORDER_BUFFER_CHANGE_INTERNAL_TUPLECID,

  61. 	REORDER_BUFFER_CHANGE_INTERNAL_SPEC_INSERT,

  62. 	REORDER_BUFFER_CHANGE_INTERNAL_SPEC_CONFIRM,

  63. 	REORDER_BUFFER_CHANGE_TRUNCATE

  64. };

  65. 

  66. /*

  67.  * a single 'change', can be an insert (with one tuple), an update (old, new),

  68.  * or a delete (old).

  69.  *

  70.  * The same struct is also used internally for other purposes but that should

  71.  * never be visible outside reorderbuffer.c.

  72.  */

  73. typedef struct ReorderBufferChange

  74. {

  75. 	XLogRecPtr	lsn;

  76. 

  77. 	/* The type of change. */

  78. 	enum ReorderBufferChangeType action;

  79. 

  80. 	RepOriginId origin_id;

  81. 

  82. 	/*

  83. 	 * Context data for the change. Which part of the union is valid depends

  84. 	 * on action.

  85. 	 */

  86. 	union

  87. 	{

  88. 		/* Old, new tuples when action == *_INSERT|UPDATE|DELETE */

  89. 		struct

  90. 		{

  91. 			/* relation that has been changed */

  92. 			RelFileNode relnode;

  93. 

  94. 			/* no previously reassembled toast chunks are necessary anymore */

  95. 			bool		clear_toast_afterwards;

  96. 

  97. 			/* valid for DELETE || UPDATE */

  98. 			ReorderBufferTupleBuf *oldtuple;

  99. 			/* valid for INSERT || UPDATE */

  100. 			ReorderBufferTupleBuf *newtuple;

  101. 		}			tp;

  102. 

  103. 		/*

  104. 		 * Truncate data for REORDER_BUFFER_CHANGE_TRUNCATE representing one

  105. 		 * set of relations to be truncated.

  106. 		 */

  107. 		struct

  108. 		{

  109. 			Size		nrelids;

  110. 			bool		cascade;

  111. 			bool		restart_seqs;

  112. 			Oid		   *relids;

  113. 		}			truncate;

  114. 

  115. 		/* Message with arbitrary data. */

  116. 		struct

  117. 		{

  118. 			char	   *prefix;

  119. 			Size		message_size;

  120. 			char	   *message;

  121. 		}			msg;

  122. 

  123. 		/* New snapshot, set when action == *_INTERNAL_SNAPSHOT */

  124. 		Snapshot	snapshot;

  125. 

  126. 		/*

  127. 		 * New command id for existing snapshot in a catalog changing tx. Set

  128. 		 * when action == *_INTERNAL_COMMAND_ID.

  129. 		 */

  130. 		CommandId	command_id;

  131. 

  132. 		/*

  133. 		 * New cid mapping for catalog changing transaction, set when action

  134. 		 * == *_INTERNAL_TUPLECID.

  135. 		 */

  136. 		struct

  137. 		{

  138. 			RelFileNode node;

  139. 			ItemPointerData tid;

  140. 			CommandId	cmin;

  141. 			CommandId	cmax;

  142. 			CommandId	combocid;

  143. 		}			tuplecid;

  144. 	}			data;

  145. 

  146. 	/*

  147. 	 * While in use this is how a change is linked into a transactions,

  148. 	 * otherwise it's the preallocated list.

  149. 	 */

  150. 	dlist_node	node;

  151. } ReorderBufferChange;

  152. 

  153. typedef struct ReorderBufferTXN

  154. {

  155. 	/*

  156. 	 * The transactions transaction id, can be a toplevel or sub xid.

  157. 	 */

  158. 	TransactionId xid;

  159. 

  160. 	/* did the TX have catalog changes */

  161. 	bool		has_catalog_changes;

  162. 

  163. 	/* Do we know this is a subxact?  Xid of top-level txn if so */

  164. 	bool		is_known_as_subxact;

  165. 	TransactionId toplevel_xid;

  166. 

  167. 	/*

  168. 	 * LSN of the first data carrying, WAL record with knowledge about this

  169. 	 * xid. This is allowed to *not* be first record adorned with this xid, if

  170. 	 * the previous records aren't relevant for logical decoding.

  171. 	 */

  172. 	XLogRecPtr	first_lsn;

  173. 

  174. 	/* ----

  175. 	 * LSN of the record that lead to this xact to be committed or

  176. 	 * aborted. This can be a

  177. 	 * * plain commit record

  178. 	 * * plain commit record, of a parent transaction

  179. 	 * * prepared transaction commit

  180. 	 * * plain abort record

  181. 	 * * prepared transaction abort

  182. 	 *

  183. 	 * This can also become set to earlier values than transaction end when

  184. 	 * a transaction is spilled to disk; specifically it's set to the LSN of

  185. 	 * the latest change written to disk so far.

  186. 	 * ----

  187. 	 */

  188. 	XLogRecPtr	final_lsn;

  189. 

  190. 	/*

  191. 	 * LSN pointing to the end of the commit record + 1.

  192. 	 */

  193. 	XLogRecPtr	end_lsn;

  194. 

  195. 	/*

  196. 	 * LSN of the last lsn at which snapshot information reside, so we can

  197. 	 * restart decoding from there and fully recover this transaction from

  198. 	 * WAL.

  199. 	 */

  200. 	XLogRecPtr	restart_decoding_lsn;

  201. 

  202. 	/* origin of the change that caused this transaction */

  203. 	RepOriginId origin_id;

  204. 	XLogRecPtr	origin_lsn;

  205. 

  206. 	/*

  207. 	 * Commit time, only known when we read the actual commit record.

  208. 	 */

  209. 	TimestampTz commit_time;

  210. 

  211. 	/*

  212. 	 * The base snapshot is used to decode all changes until either this

  213. 	 * transaction modifies the catalog, or another catalog-modifying

  214. 	 * transaction commits.

  215. 	 */

  216. 	Snapshot	base_snapshot;

  217. 	XLogRecPtr	base_snapshot_lsn;

  218. 	dlist_node	base_snapshot_node; /* link in txns_by_base_snapshot_lsn */

  219. 

  220. 	/*

  221. 	 * How many ReorderBufferChange's do we have in this txn.

  222. 	 *

  223. 	 * Changes in subtransactions are *not* included but tracked separately.

  224. 	 */

  225. 	uint64		nentries;

  226. 

  227. 	/*

  228. 	 * How many of the above entries are stored in memory in contrast to being

  229. 	 * spilled to disk.

  230. 	 */

  231. 	uint64		nentries_mem;

  232. 

  233. 	/*

  234. 	 * Has this transaction been spilled to disk?  It's not always possible to

  235. 	 * deduce that fact by comparing nentries with nentries_mem, because e.g.

  236. 	 * subtransactions of a large transaction might get serialized together

  237. 	 * with the parent - if they're restored to memory they'd have

  238. 	 * nentries_mem == nentries.

  239. 	 */

  240. 	bool		serialized;

  241. 

  242. 	/*

  243. 	 * List of ReorderBufferChange structs, including new Snapshots and new

  244. 	 * CommandIds

  245. 	 */

  246. 	dlist_head	changes;

  247. 

  248. 	/*

  249. 	 * List of (relation, ctid) => (cmin, cmax) mappings for catalog tuples.

  250. 	 * Those are always assigned to the toplevel transaction. (Keep track of

  251. 	 * #entries to create a hash of the right size)

  252. 	 */

  253. 	dlist_head	tuplecids;

  254. 	uint64		ntuplecids;

  255. 

  256. 	/*

  257. 	 * On-demand built hash for looking up the above values.

  258. 	 */

  259. 	HTAB	   *tuplecid_hash;

  260. 

  261. 	/*

  262. 	 * Hash containing (potentially partial) toast entries. NULL if no toast

  263. 	 * tuples have been found for the current change.

  264. 	 */

  265. 	HTAB	   *toast_hash;

  266. 

  267. 	/*

  268. 	 * non-hierarchical list of subtransactions that are *not* aborted. Only

  269. 	 * used in toplevel transactions.

  270. 	 */

  271. 	dlist_head	subtxns;

  272. 	uint32		nsubtxns;

  273. 

  274. 	/*

  275. 	 * Stored cache invalidations. This is not a linked list because we get

  276. 	 * all the invalidations at once.

  277. 	 */

  278. 	uint32		ninvalidations;

  279. 	SharedInvalidationMessage *invalidations;

  280. 

  281. 	/* ---

  282. 	 * Position in one of three lists:

  283. 	 * * list of subtransactions if we are *known* to be subxact

  284. 	 * * list of toplevel xacts (can be an as-yet unknown subxact)

  285. 	 * * list of preallocated ReorderBufferTXNs (if unused)

  286. 	 * ---

  287. 	 */

  288. 	dlist_node	node;

  289. 

  290. } ReorderBufferTXN;

  291. 

  292. /* so we can define the callbacks used inside struct ReorderBuffer itself */

  293. typedef struct ReorderBuffer ReorderBuffer;

  294. 

  295. /* change callback signature */

  296. typedef void (*ReorderBufferApplyChangeCB) (ReorderBuffer *rb,

  297. 											ReorderBufferTXN *txn,

  298. 											Relation relation,

  299. 											ReorderBufferChange *change);

  300. 

  301. /* truncate callback signature */

  302. typedef void (*ReorderBufferApplyTruncateCB) (ReorderBuffer *rb,

  303. 											  ReorderBufferTXN *txn,

  304. 											  int nrelations,

  305. 											  Relation relations[],

  306. 											  ReorderBufferChange *change);

  307. 

  308. /* begin callback signature */

  309. typedef void (*ReorderBufferBeginCB) (ReorderBuffer *rb,

  310. 									  ReorderBufferTXN *txn);

  311. 

  312. /* commit callback signature */

  313. typedef void (*ReorderBufferCommitCB) (ReorderBuffer *rb,

  314. 									   ReorderBufferTXN *txn,

  315. 									   XLogRecPtr commit_lsn);

  316. 

  317. /* message callback signature */

  318. typedef void (*ReorderBufferMessageCB) (ReorderBuffer *rb,

  319. 										ReorderBufferTXN *txn,

  320. 										XLogRecPtr message_lsn,

  321. 										bool transactional,

  322. 										const char *prefix, Size sz,

  323. 										const char *message);

  324. 

  325. struct ReorderBuffer

  326. {

  327. 	/*

  328. 	 * xid => ReorderBufferTXN lookup table

  329. 	 */

  330. 	HTAB	   *by_txn;

  331. 

  332. 	/*

  333. 	 * Transactions that could be a toplevel xact, ordered by LSN of the first

  334. 	 * record bearing that xid.

  335. 	 */

  336. 	dlist_head	toplevel_by_lsn;

  337. 

  338. 	/*

  339. 	 * Transactions and subtransactions that have a base snapshot, ordered by

  340. 	 * LSN of the record which caused us to first obtain the base snapshot.

  341. 	 * This is not the same as toplevel_by_lsn, because we only set the base

  342. 	 * snapshot on the first logical-decoding-relevant record (eg. heap

  343. 	 * writes), whereas the initial LSN could be set by other operations.

  344. 	 */

  345. 	dlist_head	txns_by_base_snapshot_lsn;

  346. 

  347. 	/*

  348. 	 * one-entry sized cache for by_txn. Very frequently the same txn gets

  349. 	 * looked up over and over again.

  350. 	 */

  351. 	TransactionId by_txn_last_xid;

  352. 	ReorderBufferTXN *by_txn_last_txn;

  353. 

  354. 	/*

  355. 	 * Callbacks to be called when a transactions commits.

  356. 	 */

  357. 	ReorderBufferBeginCB begin;

  358. 	ReorderBufferApplyChangeCB apply_change;

  359. 	ReorderBufferApplyTruncateCB apply_truncate;

  360. 	ReorderBufferCommitCB commit;

  361. 	ReorderBufferMessageCB message;

  362. 

  363. 	/*

  364. 	 * Pointer that will be passed untouched to the callbacks.

  365. 	 */

  366. 	void	   *private_data;

  367. 

  368. 	/*

  369. 	 * Saved output plugin option

  370. 	 */

  371. 	bool		output_rewrites;

  372. 

  373. 	/*

  374. 	 * Private memory context.

  375. 	 */

  376. 	MemoryContext context;

  377. 

  378. 	/*

  379. 	 * Memory contexts for specific types objects

  380. 	 */

  381. 	MemoryContext change_context;

  382. 	MemoryContext txn_context;

  383. 	MemoryContext tup_context;

  384. 

  385. 	XLogRecPtr	current_restart_decoding_lsn;

  386. 

  387. 	/* buffer for disk<->memory conversions */

  388. 	char	   *outbuf;

  389. 	Size		outbufsize;

  390. };

  391. 

  392. 

  393. ReorderBuffer *ReorderBufferAllocate(void);

  394. void		ReorderBufferFree(ReorderBuffer *);

  395. 

  396. ReorderBufferTupleBuf *ReorderBufferGetTupleBuf(ReorderBuffer *, Size tuple_len);

  397. void		ReorderBufferReturnTupleBuf(ReorderBuffer *, ReorderBufferTupleBuf *tuple);

  398. ReorderBufferChange *ReorderBufferGetChange(ReorderBuffer *);

  399. void		ReorderBufferReturnChange(ReorderBuffer *, ReorderBufferChange *);

  400. 

  401. Oid		   *ReorderBufferGetRelids(ReorderBuffer *, int nrelids);

  402. void		ReorderBufferReturnRelids(ReorderBuffer *, Oid *relids);

  403. 

  404. void		ReorderBufferQueueChange(ReorderBuffer *, TransactionId, XLogRecPtr lsn, ReorderBufferChange *);

  405. void		ReorderBufferQueueMessage(ReorderBuffer *, TransactionId, Snapshot snapshot, XLogRecPtr lsn,

  406. 									  bool transactional, const char *prefix,

  407. 									  Size message_size, const char *message);

  408. void		ReorderBufferCommit(ReorderBuffer *, TransactionId,

  409. 								XLogRecPtr commit_lsn, XLogRecPtr end_lsn,

  410. 								TimestampTz commit_time, RepOriginId origin_id, XLogRecPtr origin_lsn);

  411. void		ReorderBufferAssignChild(ReorderBuffer *, TransactionId, TransactionId, XLogRecPtr commit_lsn);

  412. void		ReorderBufferCommitChild(ReorderBuffer *, TransactionId, TransactionId,

  413. 									 XLogRecPtr commit_lsn, XLogRecPtr end_lsn);

  414. void		ReorderBufferAbort(ReorderBuffer *, TransactionId, XLogRecPtr lsn);

  415. void		ReorderBufferAbortOld(ReorderBuffer *, TransactionId xid);

  416. void		ReorderBufferForget(ReorderBuffer *, TransactionId, XLogRecPtr lsn);

  417. 

  418. void		ReorderBufferSetBaseSnapshot(ReorderBuffer *, TransactionId, XLogRecPtr lsn, struct SnapshotData *snap);

  419. void		ReorderBufferAddSnapshot(ReorderBuffer *, TransactionId, XLogRecPtr lsn, struct SnapshotData *snap);

  420. void		ReorderBufferAddNewCommandId(ReorderBuffer *, TransactionId, XLogRecPtr lsn,

  421. 										 CommandId cid);

  422. void		ReorderBufferAddNewTupleCids(ReorderBuffer *, TransactionId, XLogRecPtr lsn,

  423. 										 RelFileNode node, ItemPointerData pt,

  424. 										 CommandId cmin, CommandId cmax, CommandId combocid);

  425. void		ReorderBufferAddInvalidations(ReorderBuffer *, TransactionId, XLogRecPtr lsn,

  426. 										  Size nmsgs, SharedInvalidationMessage *msgs);

  427. void		ReorderBufferImmediateInvalidation(ReorderBuffer *, uint32 ninvalidations,

  428. 											   SharedInvalidationMessage *invalidations);

  429. void		ReorderBufferProcessXid(ReorderBuffer *, TransactionId xid, XLogRecPtr lsn);

  430. void		ReorderBufferXidSetCatalogChanges(ReorderBuffer *, TransactionId xid, XLogRecPtr lsn);

  431. bool		ReorderBufferXidHasCatalogChanges(ReorderBuffer *, TransactionId xid);

  432. bool		ReorderBufferXidHasBaseSnapshot(ReorderBuffer *, TransactionId xid);

  433. 

  434. ReorderBufferTXN *ReorderBufferGetOldestTXN(ReorderBuffer *);

  435. TransactionId ReorderBufferGetOldestXmin(ReorderBuffer *rb);

  436. 

  437. void		ReorderBufferSetRestartPoint(ReorderBuffer *, XLogRecPtr ptr);

  438. 

  439. void		StartupReorderBuffer(void);

  440. 

  441. #endif
上海开阖软件有限公司 沪ICP备12045867号-1