pg_query 2.2.0 → 6.1.0

data/ext/pg_query/include/access/xlogreader.h

@@ -1,337 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * xlogreader.h
- *		Definitions for the generic XLog reading facility
- *
- * Portions Copyright (c) 2013-2020, PostgreSQL Global Development Group
- *
- * IDENTIFICATION
- *		src/include/access/xlogreader.h
- *
- * NOTES
- *		See the definition of the XLogReaderState struct for instructions on
- *		how to use the XLogReader infrastructure.
- *
- *		The basic idea is to allocate an XLogReaderState via
- *		XLogReaderAllocate(), position the reader to the first record with
- *		XLogBeginRead() or XLogFindNextRecord(), and call XLogReadRecord()
- *		until it returns NULL.
- *
- *		Callers supply a page_read callback if they want to to call
- *		XLogReadRecord or XLogFindNextRecord; it can be passed in as NULL
- *		otherwise.  The WALRead function can be used as a helper to write
- *		page_read callbacks, but it is not mandatory; callers that use it,
- *		must supply segment_open callbacks.  The segment_close callback
- *		must always be supplied.
- *
- *		After reading a record with XLogReadRecord(), it's decomposed into
- *		the per-block and main data parts, and the parts can be accessed
- *		with the XLogRec* macros and functions. You can also decode a
- *		record that's already constructed in memory, without reading from
- *		disk, by calling the DecodeXLogRecord() function.
- *-------------------------------------------------------------------------
- */
-#ifndef XLOGREADER_H
-#define XLOGREADER_H
-
-#ifndef FRONTEND
-#include "access/transam.h"
-#endif
-
-#include "access/xlogrecord.h"
-
-/* WALOpenSegment represents a WAL segment being read. */
-typedef struct WALOpenSegment
-{
-	int			ws_file;		/* segment file descriptor */
-	XLogSegNo	ws_segno;		/* segment number */
-	TimeLineID	ws_tli;			/* timeline ID of the currently open file */
-} WALOpenSegment;
-
-/* WALSegmentContext carries context information about WAL segments to read */
-typedef struct WALSegmentContext
-{
-	char		ws_dir[MAXPGPATH];
-	int			ws_segsize;
-} WALSegmentContext;
-
-typedef struct XLogReaderState XLogReaderState;
-
-/* Function type definitions for various xlogreader interactions */
-typedef int (*XLogPageReadCB) (XLogReaderState *xlogreader,
-							   XLogRecPtr targetPagePtr,
-							   int reqLen,
-							   XLogRecPtr targetRecPtr,
-							   char *readBuf);
-typedef void (*WALSegmentOpenCB) (XLogReaderState *xlogreader,
-								  XLogSegNo nextSegNo,
-								  TimeLineID *tli_p);
-typedef void (*WALSegmentCloseCB) (XLogReaderState *xlogreader);
-
-typedef struct XLogReaderRoutine
-{
-	/*
-	 * Data input callback
-	 *
-	 * This callback shall read at least reqLen valid bytes of the xlog page
-	 * starting at targetPagePtr, and store them in readBuf.  The callback
-	 * shall return the number of bytes read (never more than XLOG_BLCKSZ), or
-	 * -1 on failure.  The callback shall sleep, if necessary, to wait for the
-	 * requested bytes to become available.  The callback will not be invoked
-	 * again for the same page unless more than the returned number of bytes
-	 * are needed.
-	 *
-	 * targetRecPtr is the position of the WAL record we're reading.  Usually
-	 * it is equal to targetPagePtr + reqLen, but sometimes xlogreader needs
-	 * to read and verify the page or segment header, before it reads the
-	 * actual WAL record it's interested in.  In that case, targetRecPtr can
-	 * be used to determine which timeline to read the page from.
-	 *
-	 * The callback shall set ->seg.ws_tli to the TLI of the file the page was
-	 * read from.
-	 */
-	XLogPageReadCB page_read;
-
-	/*
-	 * Callback to open the specified WAL segment for reading.  ->seg.ws_file
-	 * shall be set to the file descriptor of the opened segment.  In case of
-	 * failure, an error shall be raised by the callback and it shall not
-	 * return.
-	 *
-	 * "nextSegNo" is the number of the segment to be opened.
-	 *
-	 * "tli_p" is an input/output argument. WALRead() uses it to pass the
-	 * timeline in which the new segment should be found, but the callback can
-	 * use it to return the TLI that it actually opened.
-	 */
-	WALSegmentOpenCB segment_open;
-
-	/*
-	 * WAL segment close callback.  ->seg.ws_file shall be set to a negative
-	 * number.
-	 */
-	WALSegmentCloseCB segment_close;
-} XLogReaderRoutine;
-
-#define XL_ROUTINE(...) &(XLogReaderRoutine){__VA_ARGS__}
-
-typedef struct
-{
-	/* Is this block ref in use? */
-	bool		in_use;
-
-	/* Identify the block this refers to */
-	RelFileNode rnode;
-	ForkNumber	forknum;
-	BlockNumber blkno;
-
-	/* copy of the fork_flags field from the XLogRecordBlockHeader */
-	uint8		flags;
-
-	/* Information on full-page image, if any */
-	bool		has_image;		/* has image, even for consistency checking */
-	bool		apply_image;	/* has image that should be restored */
-	char	   *bkp_image;
-	uint16		hole_offset;
-	uint16		hole_length;
-	uint16		bimg_len;
-	uint8		bimg_info;
-
-	/* Buffer holding the rmgr-specific data associated with this block */
-	bool		has_data;
-	char	   *data;
-	uint16		data_len;
-	uint16		data_bufsz;
-} DecodedBkpBlock;
-
-struct XLogReaderState
-{
-	/*
-	 * Operational callbacks
-	 */
-	XLogReaderRoutine routine;
-
-	/* ----------------------------------------
-	 * Public parameters
-	 * ----------------------------------------
-	 */
-
-	/*
-	 * System identifier of the xlog files we're about to read.  Set to zero
-	 * (the default value) if unknown or unimportant.
-	 */
-	uint64		system_identifier;
-
-	/*
-	 * Opaque data for callbacks to use.  Not used by XLogReader.
-	 */
-	void	   *private_data;
-
-	/*
-	 * Start and end point of last record read.  EndRecPtr is also used as the
-	 * position to read next.  Calling XLogBeginRead() sets EndRecPtr to the
-	 * starting position and ReadRecPtr to invalid.
-	 */
-	XLogRecPtr	ReadRecPtr;		/* start of last record read */
-	XLogRecPtr	EndRecPtr;		/* end+1 of last record read */
-
-
-	/* ----------------------------------------
-	 * Decoded representation of current record
-	 *
-	 * Use XLogRecGet* functions to investigate the record; these fields
-	 * should not be accessed directly.
-	 * ----------------------------------------
-	 */
-	XLogRecord *decoded_record; /* currently decoded record */
-
-	char	   *main_data;		/* record's main data portion */
-	uint32		main_data_len;	/* main data portion's length */
-	uint32		main_data_bufsz;	/* allocated size of the buffer */
-
-	RepOriginId record_origin;
-
-	/* information about blocks referenced by the record. */
-	DecodedBkpBlock blocks[XLR_MAX_BLOCK_ID + 1];
-
-	int			max_block_id;	/* highest block_id in use (-1 if none) */
-
-	/* ----------------------------------------
-	 * private/internal state
-	 * ----------------------------------------
-	 */
-
-	/*
-	 * Buffer for currently read page (XLOG_BLCKSZ bytes, valid up to at least
-	 * readLen bytes)
-	 */
-	char	   *readBuf;
-	uint32		readLen;
-
-	/* last read XLOG position for data currently in readBuf */
-	WALSegmentContext segcxt;
-	WALOpenSegment seg;
-	uint32		segoff;
-
-	/*
-	 * beginning of prior page read, and its TLI.  Doesn't necessarily
-	 * correspond to what's in readBuf; used for timeline sanity checks.
-	 */
-	XLogRecPtr	latestPagePtr;
-	TimeLineID	latestPageTLI;
-
-	/* beginning of the WAL record being read. */
-	XLogRecPtr	currRecPtr;
-	/* timeline to read it from, 0 if a lookup is required */
-	TimeLineID	currTLI;
-
-	/*
-	 * Safe point to read to in currTLI if current TLI is historical
-	 * (tliSwitchPoint) or InvalidXLogRecPtr if on current timeline.
-	 *
-	 * Actually set to the start of the segment containing the timeline switch
-	 * that ends currTLI's validity, not the LSN of the switch its self, since
-	 * we can't assume the old segment will be present.
-	 */
-	XLogRecPtr	currTLIValidUntil;
-
-	/*
-	 * If currTLI is not the most recent known timeline, the next timeline to
-	 * read from when currTLIValidUntil is reached.
-	 */
-	TimeLineID	nextTLI;
-
-	/*
-	 * Buffer for current ReadRecord result (expandable), used when a record
-	 * crosses a page boundary.
-	 */
-	char	   *readRecordBuf;
-	uint32		readRecordBufSize;
-
-	/* Buffer to hold error message */
-	char	   *errormsg_buf;
-
-	/*
-	 * Set at the end of recovery: the start point of a partial record at the
-	 * end of WAL (InvalidXLogRecPtr if there wasn't one), and the start
-	 * location of its first contrecord that went missing.
-	 */
-	XLogRecPtr	abortedRecPtr;
-	XLogRecPtr	missingContrecPtr;
-	/* Set when XLP_FIRST_IS_OVERWRITE_CONTRECORD is found */
-	XLogRecPtr	overwrittenRecPtr;
-};
-
-/* Get a new XLogReader */
-extern XLogReaderState *XLogReaderAllocate(int wal_segment_size,
-										   const char *waldir,
-										   XLogReaderRoutine *routine,
-										   void *private_data);
-extern XLogReaderRoutine *LocalXLogReaderRoutine(void);
-
-/* Free an XLogReader */
-extern void XLogReaderFree(XLogReaderState *state);
-
-/* Position the XLogReader to given record */
-extern void XLogBeginRead(XLogReaderState *state, XLogRecPtr RecPtr);
-#ifdef FRONTEND
-extern XLogRecPtr XLogFindNextRecord(XLogReaderState *state, XLogRecPtr RecPtr);
-#endif							/* FRONTEND */
-
-/* Read the next XLog record. Returns NULL on end-of-WAL or failure */
-extern struct XLogRecord *XLogReadRecord(XLogReaderState *state,
-										 char **errormsg);
-
-/* Validate a page */
-extern bool XLogReaderValidatePageHeader(XLogReaderState *state,
-										 XLogRecPtr recptr, char *phdr);
-
-/*
- * Error information from WALRead that both backend and frontend caller can
- * process.  Currently only errors from pg_pread can be reported.
- */
-typedef struct WALReadError
-{
-	int			wre_errno;		/* errno set by the last pg_pread() */
-	int			wre_off;		/* Offset we tried to read from. */
-	int			wre_req;		/* Bytes requested to be read. */
-	int			wre_read;		/* Bytes read by the last read(). */
-	WALOpenSegment wre_seg;		/* Segment we tried to read from. */
-} WALReadError;
-
-extern bool WALRead(XLogReaderState *state,
-					char *buf, XLogRecPtr startptr, Size count,
-					TimeLineID tli, WALReadError *errinfo);
-
-/* Functions for decoding an XLogRecord */
-
-extern bool DecodeXLogRecord(XLogReaderState *state, XLogRecord *record,
-							 char **errmsg);
-
-#define XLogRecGetTotalLen(decoder) ((decoder)->decoded_record->xl_tot_len)
-#define XLogRecGetPrev(decoder) ((decoder)->decoded_record->xl_prev)
-#define XLogRecGetInfo(decoder) ((decoder)->decoded_record->xl_info)
-#define XLogRecGetRmid(decoder) ((decoder)->decoded_record->xl_rmid)
-#define XLogRecGetXid(decoder) ((decoder)->decoded_record->xl_xid)
-#define XLogRecGetOrigin(decoder) ((decoder)->record_origin)
-#define XLogRecGetData(decoder) ((decoder)->main_data)
-#define XLogRecGetDataLen(decoder) ((decoder)->main_data_len)
-#define XLogRecHasAnyBlockRefs(decoder) ((decoder)->max_block_id >= 0)
-#define XLogRecHasBlockRef(decoder, block_id) \
-	((decoder)->blocks[block_id].in_use)
-#define XLogRecHasBlockImage(decoder, block_id) \
-	((decoder)->blocks[block_id].has_image)
-#define XLogRecBlockImageApply(decoder, block_id) \
-	((decoder)->blocks[block_id].apply_image)
-
-#ifndef FRONTEND
-extern FullTransactionId XLogRecGetFullXid(XLogReaderState *record);
-#endif
-
-extern bool RestoreBlockImage(XLogReaderState *record, uint8 block_id, char *page);
-extern char *XLogRecGetBlockData(XLogReaderState *record, uint8 block_id, Size *len);
-extern bool XLogRecGetBlockTag(XLogReaderState *record, uint8 block_id,
-							   RelFileNode *rnode, ForkNumber *forknum,
-							   BlockNumber *blknum);
-
-#endif							/* XLOGREADER_H */

data/ext/pg_query/include/access/xlogrecord.h

@@ -1,227 +0,0 @@
-/*
- * xlogrecord.h
- *
- * Definitions for the WAL record format.
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/access/xlogrecord.h
- */
-#ifndef XLOGRECORD_H
-#define XLOGRECORD_H
-
-#include "access/rmgr.h"
-#include "access/xlogdefs.h"
-#include "port/pg_crc32c.h"
-#include "storage/block.h"
-#include "storage/relfilenode.h"
-
-/*
- * The overall layout of an XLOG record is:
- *		Fixed-size header (XLogRecord struct)
- *		XLogRecordBlockHeader struct
- *		XLogRecordBlockHeader struct
- *		...
- *		XLogRecordDataHeader[Short|Long] struct
- *		block data
- *		block data
- *		...
- *		main data
- *
- * There can be zero or more XLogRecordBlockHeaders, and 0 or more bytes of
- * rmgr-specific data not associated with a block.  XLogRecord structs
- * always start on MAXALIGN boundaries in the WAL files, but the rest of
- * the fields are not aligned.
- *
- * The XLogRecordBlockHeader, XLogRecordDataHeaderShort and
- * XLogRecordDataHeaderLong structs all begin with a single 'id' byte. It's
- * used to distinguish between block references, and the main data structs.
- */
-typedef struct XLogRecord
-{
-	uint32		xl_tot_len;		/* total len of entire record */
-	TransactionId xl_xid;		/* xact id */
-	XLogRecPtr	xl_prev;		/* ptr to previous record in log */
-	uint8		xl_info;		/* flag bits, see below */
-	RmgrId		xl_rmid;		/* resource manager for this record */
-	/* 2 bytes of padding here, initialize to zero */
-	pg_crc32c	xl_crc;			/* CRC for this record */
-
-	/* XLogRecordBlockHeaders and XLogRecordDataHeader follow, no padding */
-
-} XLogRecord;
-
-#define SizeOfXLogRecord	(offsetof(XLogRecord, xl_crc) + sizeof(pg_crc32c))
-
-/*
- * The high 4 bits in xl_info may be used freely by rmgr. The
- * XLR_SPECIAL_REL_UPDATE and XLR_CHECK_CONSISTENCY bits can be passed by
- * XLogInsert caller. The rest are set internally by XLogInsert.
- */
-#define XLR_INFO_MASK			0x0F
-#define XLR_RMGR_INFO_MASK		0xF0
-
-/*
- * If a WAL record modifies any relation files, in ways not covered by the
- * usual block references, this flag is set. This is not used for anything
- * by PostgreSQL itself, but it allows external tools that read WAL and keep
- * track of modified blocks to recognize such special record types.
- */
-#define XLR_SPECIAL_REL_UPDATE	0x01
-
-/*
- * Enforces consistency checks of replayed WAL at recovery. If enabled,
- * each record will log a full-page write for each block modified by the
- * record and will reuse it afterwards for consistency checks. The caller
- * of XLogInsert can use this value if necessary, but if
- * wal_consistency_checking is enabled for a rmgr this is set unconditionally.
- */
-#define XLR_CHECK_CONSISTENCY	0x02
-
-/*
- * Header info for block data appended to an XLOG record.
- *
- * 'data_length' is the length of the rmgr-specific payload data associated
- * with this block. It does not include the possible full page image, nor
- * XLogRecordBlockHeader struct itself.
- *
- * Note that we don't attempt to align the XLogRecordBlockHeader struct!
- * So, the struct must be copied to aligned local storage before use.
- */
-typedef struct XLogRecordBlockHeader
-{
-	uint8		id;				/* block reference ID */
-	uint8		fork_flags;		/* fork within the relation, and flags */
-	uint16		data_length;	/* number of payload bytes (not including page
-								 * image) */
-
-	/* If BKPBLOCK_HAS_IMAGE, an XLogRecordBlockImageHeader struct follows */
-	/* If BKPBLOCK_SAME_REL is not set, a RelFileNode follows */
-	/* BlockNumber follows */
-} XLogRecordBlockHeader;
-
-#define SizeOfXLogRecordBlockHeader (offsetof(XLogRecordBlockHeader, data_length) + sizeof(uint16))
-
-/*
- * Additional header information when a full-page image is included
- * (i.e. when BKPBLOCK_HAS_IMAGE is set).
- *
- * The XLOG code is aware that PG data pages usually contain an unused "hole"
- * in the middle, which contains only zero bytes.  Since we know that the
- * "hole" is all zeros, we remove it from the stored data (and it's not counted
- * in the XLOG record's CRC, either).  Hence, the amount of block data actually
- * present is (BLCKSZ - <length of "hole" bytes>).
- *
- * Additionally, when wal_compression is enabled, we will try to compress full
- * page images using the PGLZ compression algorithm, after removing the "hole".
- * This can reduce the WAL volume, but at some extra cost of CPU spent
- * on the compression during WAL logging. In this case, since the "hole"
- * length cannot be calculated by subtracting the number of page image bytes
- * from BLCKSZ, basically it needs to be stored as an extra information.
- * But when no "hole" exists, we can assume that the "hole" length is zero
- * and no such an extra information needs to be stored. Note that
- * the original version of page image is stored in WAL instead of the
- * compressed one if the number of bytes saved by compression is less than
- * the length of extra information. Hence, when a page image is successfully
- * compressed, the amount of block data actually present is less than
- * BLCKSZ - the length of "hole" bytes - the length of extra information.
- */
-typedef struct XLogRecordBlockImageHeader
-{
-	uint16		length;			/* number of page image bytes */
-	uint16		hole_offset;	/* number of bytes before "hole" */
-	uint8		bimg_info;		/* flag bits, see below */
-
-	/*
-	 * If BKPIMAGE_HAS_HOLE and BKPIMAGE_IS_COMPRESSED, an
-	 * XLogRecordBlockCompressHeader struct follows.
-	 */
-} XLogRecordBlockImageHeader;
-
-#define SizeOfXLogRecordBlockImageHeader	\
-	(offsetof(XLogRecordBlockImageHeader, bimg_info) + sizeof(uint8))
-
-/* Information stored in bimg_info */
-#define BKPIMAGE_HAS_HOLE		0x01	/* page image has "hole" */
-#define BKPIMAGE_IS_COMPRESSED		0x02	/* page image is compressed */
-#define BKPIMAGE_APPLY		0x04	/* page image should be restored during
-									 * replay */
-
-/*
- * Extra header information used when page image has "hole" and
- * is compressed.
- */
-typedef struct XLogRecordBlockCompressHeader
-{
-	uint16		hole_length;	/* number of bytes in "hole" */
-} XLogRecordBlockCompressHeader;
-
-#define SizeOfXLogRecordBlockCompressHeader \
-	sizeof(XLogRecordBlockCompressHeader)
-
-/*
- * Maximum size of the header for a block reference. This is used to size a
- * temporary buffer for constructing the header.
- */
-#define MaxSizeOfXLogRecordBlockHeader \
-	(SizeOfXLogRecordBlockHeader + \
-	 SizeOfXLogRecordBlockImageHeader + \
-	 SizeOfXLogRecordBlockCompressHeader + \
-	 sizeof(RelFileNode) + \
-	 sizeof(BlockNumber))
-
-/*
- * The fork number fits in the lower 4 bits in the fork_flags field. The upper
- * bits are used for flags.
- */
-#define BKPBLOCK_FORK_MASK	0x0F
-#define BKPBLOCK_FLAG_MASK	0xF0
-#define BKPBLOCK_HAS_IMAGE	0x10	/* block data is an XLogRecordBlockImage */
-#define BKPBLOCK_HAS_DATA	0x20
-#define BKPBLOCK_WILL_INIT	0x40	/* redo will re-init the page */
-#define BKPBLOCK_SAME_REL	0x80	/* RelFileNode omitted, same as previous */
-
-/*
- * XLogRecordDataHeaderShort/Long are used for the "main data" portion of
- * the record. If the length of the data is less than 256 bytes, the short
- * form is used, with a single byte to hold the length. Otherwise the long
- * form is used.
- *
- * (These structs are currently not used in the code, they are here just for
- * documentation purposes).
- */
-typedef struct XLogRecordDataHeaderShort
-{
-	uint8		id;				/* XLR_BLOCK_ID_DATA_SHORT */
-	uint8		data_length;	/* number of payload bytes */
-}			XLogRecordDataHeaderShort;
-
-#define SizeOfXLogRecordDataHeaderShort (sizeof(uint8) * 2)
-
-typedef struct XLogRecordDataHeaderLong
-{
-	uint8		id;				/* XLR_BLOCK_ID_DATA_LONG */
-	/* followed by uint32 data_length, unaligned */
-}			XLogRecordDataHeaderLong;
-
-#define SizeOfXLogRecordDataHeaderLong (sizeof(uint8) + sizeof(uint32))
-
-/*
- * Block IDs used to distinguish different kinds of record fragments. Block
- * references are numbered from 0 to XLR_MAX_BLOCK_ID. A rmgr is free to use
- * any ID number in that range (although you should stick to small numbers,
- * because the WAL machinery is optimized for that case). A couple of ID
- * numbers are reserved to denote the "main" data portion of the record.
- *
- * The maximum is currently set at 32, quite arbitrarily. Most records only
- * need a handful of block references, but there are a few exceptions that
- * need more.
- */
-#define XLR_MAX_BLOCK_ID			32
-
-#define XLR_BLOCK_ID_DATA_SHORT		255
-#define XLR_BLOCK_ID_DATA_LONG		254
-#define XLR_BLOCK_ID_ORIGIN			253
-
-#endif							/* XLOGRECORD_H */

data/ext/pg_query/include/bootstrap/bootstrap.h

@@ -1,62 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * bootstrap.h
- *	  include file for the bootstrapping code
- *
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/bootstrap/bootstrap.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef BOOTSTRAP_H
-#define BOOTSTRAP_H
-
-#include "nodes/execnodes.h"
-
-
-/*
- * MAXATTR is the maximum number of attributes in a relation supported
- * at bootstrap time (i.e., the max possible in a system table).
- */
-#define MAXATTR 40
-
-#define BOOTCOL_NULL_AUTO			1
-#define BOOTCOL_NULL_FORCE_NULL		2
-#define BOOTCOL_NULL_FORCE_NOT_NULL 3
-
-extern Relation boot_reldesc;
-extern Form_pg_attribute attrtypes[MAXATTR];
-extern int	numattr;
-
-
-extern void AuxiliaryProcessMain(int argc, char *argv[]) pg_attribute_noreturn();
-
-extern void closerel(char *name);
-extern void boot_openrel(char *name);
-
-extern void DefineAttr(char *name, char *type, int attnum, int nullness);
-extern void InsertOneTuple(void);
-extern void InsertOneValue(char *value, int i);
-extern void InsertOneNull(int i);
-
-extern void index_register(Oid heap, Oid ind, IndexInfo *indexInfo);
-extern void build_indices(void);
-
-extern void boot_get_type_io_data(Oid typid,
-								  int16 *typlen,
-								  bool *typbyval,
-								  char *typalign,
-								  char *typdelim,
-								  Oid *typioparam,
-								  Oid *typinput,
-								  Oid *typoutput);
-
-extern int	boot_yyparse(void);
-
-extern int	boot_yylex(void);
-extern void boot_yyerror(const char *str) pg_attribute_noreturn();
-
-#endif							/* BOOTSTRAP_H */