pg_query 4.2.1 → 6.1.0

data/ext/pg_query/include/rewrite/rewriteManip.h

@@ -1,87 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * rewriteManip.h
- *		Querytree manipulation subroutines for query rewriter.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/rewrite/rewriteManip.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef REWRITEMANIP_H
-#define REWRITEMANIP_H
-
-#include "nodes/parsenodes.h"
-
-struct AttrMap;					/* avoid including attmap.h here */
-
-
-typedef struct replace_rte_variables_context replace_rte_variables_context;
-
-typedef Node *(*replace_rte_variables_callback) (Var *var,
-												 replace_rte_variables_context *context);
-
-struct replace_rte_variables_context
-{
-	replace_rte_variables_callback callback;	/* callback function */
-	void	   *callback_arg;	/* context data for callback function */
-	int			target_varno;	/* RTE index to search for */
-	int			sublevels_up;	/* (current) nesting depth */
-	bool		inserted_sublink;	/* have we inserted a SubLink? */
-};
-
-typedef enum ReplaceVarsNoMatchOption
-{
-	REPLACEVARS_REPORT_ERROR,	/* throw error if no match */
-	REPLACEVARS_CHANGE_VARNO,	/* change the Var's varno, nothing else */
-	REPLACEVARS_SUBSTITUTE_NULL /* replace with a NULL Const */
-} ReplaceVarsNoMatchOption;
-
-
-extern void OffsetVarNodes(Node *node, int offset, int sublevels_up);
-extern void ChangeVarNodes(Node *node, int old_varno, int new_varno,
-						   int sublevels_up);
-extern void IncrementVarSublevelsUp(Node *node, int delta_sublevels_up,
-									int min_sublevels_up);
-extern void IncrementVarSublevelsUp_rtable(List *rtable,
-										   int delta_sublevels_up, int min_sublevels_up);
-
-extern bool rangeTableEntry_used(Node *node, int rt_index,
-								 int sublevels_up);
-
-extern Query *getInsertSelectQuery(Query *parsetree, Query ***subquery_ptr);
-
-extern void AddQual(Query *parsetree, Node *qual);
-extern void AddInvertedQual(Query *parsetree, Node *qual);
-
-extern bool contain_aggs_of_level(Node *node, int levelsup);
-extern int	locate_agg_of_level(Node *node, int levelsup);
-extern bool contain_windowfuncs(Node *node);
-extern int	locate_windowfunc(Node *node);
-extern bool checkExprHasSubLink(Node *node);
-
-extern Node *replace_rte_variables(Node *node,
-								   int target_varno, int sublevels_up,
-								   replace_rte_variables_callback callback,
-								   void *callback_arg,
-								   bool *outer_hasSubLinks);
-extern Node *replace_rte_variables_mutator(Node *node,
-										   replace_rte_variables_context *context);
-
-extern Node *map_variable_attnos(Node *node,
-								 int target_varno, int sublevels_up,
-								 const struct AttrMap *attno_map,
-								 Oid to_rowtype, bool *found_whole_row);
-
-extern Node *ReplaceVarsFromTargetList(Node *node,
-									   int target_varno, int sublevels_up,
-									   RangeTblEntry *target_rte,
-									   List *targetlist,
-									   ReplaceVarsNoMatchOption nomatch_option,
-									   int nomatch_varno,
-									   bool *outer_hasSubLinks);
-
-#endif							/* REWRITEMANIP_H */

data/ext/pg_query/include/rewrite/rewriteSupport.h

@@ -1,26 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * rewriteSupport.h
- *
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/rewrite/rewriteSupport.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef REWRITESUPPORT_H
-#define REWRITESUPPORT_H
-
-/* The ON SELECT rule of a view is always named this: */
-#define ViewSelectRuleName	"_RETURN"
-
-extern bool IsDefinedRewriteRule(Oid owningRel, const char *ruleName);
-
-extern void SetRelationRuleStatus(Oid relationId, bool relHasRules);
-
-extern Oid	get_rewrite_oid(Oid relid, const char *rulename, bool missing_ok);
-
-#endif							/* REWRITESUPPORT_H */

data/ext/pg_query/include/storage/backendid.h

@@ -1,37 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * backendid.h
- *	  POSTGRES backend id communication definitions
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/backendid.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef BACKENDID_H
-#define BACKENDID_H
-
-/* ----------------
- *		-cim 8/17/90
- * ----------------
- */
-typedef int BackendId;			/* unique currently active backend identifier */
-
-#define InvalidBackendId		(-1)
-
-extern PGDLLIMPORT BackendId MyBackendId;	/* backend id of this backend */
-
-/* backend id of our parallel session leader, or InvalidBackendId if none */
-extern PGDLLIMPORT BackendId ParallelLeaderBackendId;
-
-/*
- * The BackendId to use for our session's temp relations is normally our own,
- * but parallel workers should use their leader's ID.
- */
-#define BackendIdForTempRelations() \
-	(ParallelLeaderBackendId == InvalidBackendId ? MyBackendId : ParallelLeaderBackendId)
-
-#endif							/* BACKENDID_H */

data/ext/pg_query/include/storage/block.h

@@ -1,115 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * block.h
- *	  POSTGRES disk block definitions.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/block.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef BLOCK_H
-#define BLOCK_H
-
-/*
- * BlockNumber:
- *
- * each data file (heap or index) is divided into postgres disk blocks
- * (which may be thought of as the unit of i/o -- a postgres buffer
- * contains exactly one disk block).  the blocks are numbered
- * sequentially, 0 to 0xFFFFFFFE.
- *
- * InvalidBlockNumber is the same thing as P_NEW in bufmgr.h.
- *
- * the access methods, the buffer manager and the storage manager are
- * more or less the only pieces of code that should be accessing disk
- * blocks directly.
- */
-typedef uint32 BlockNumber;
-
-#define InvalidBlockNumber		((BlockNumber) 0xFFFFFFFF)
-
-#define MaxBlockNumber			((BlockNumber) 0xFFFFFFFE)
-
-/*
- * BlockId:
- *
- * this is a storage type for BlockNumber.  in other words, this type
- * is used for on-disk structures (e.g., in HeapTupleData) whereas
- * BlockNumber is the type on which calculations are performed (e.g.,
- * in access method code).
- *
- * there doesn't appear to be any reason to have separate types except
- * for the fact that BlockIds can be SHORTALIGN'd (and therefore any
- * structures that contains them, such as ItemPointerData, can also be
- * SHORTALIGN'd).  this is an important consideration for reducing the
- * space requirements of the line pointer (ItemIdData) array on each
- * page and the header of each heap or index tuple, so it doesn't seem
- * wise to change this without good reason.
- */
-typedef struct BlockIdData
-{
-	uint16		bi_hi;
-	uint16		bi_lo;
-} BlockIdData;
-
-typedef BlockIdData *BlockId;	/* block identifier */
-
-/* ----------------
- *		support macros
- * ----------------
- */
-
-/*
- * BlockNumberIsValid
- *		True iff blockNumber is valid.
- */
-#define BlockNumberIsValid(blockNumber) \
-	((BlockNumber) (blockNumber) != InvalidBlockNumber)
-
-/*
- * BlockIdIsValid
- *		True iff the block identifier is valid.
- */
-#define BlockIdIsValid(blockId) \
-	PointerIsValid(blockId)
-
-/*
- * BlockIdSet
- *		Sets a block identifier to the specified value.
- */
-#define BlockIdSet(blockId, blockNumber) \
-( \
-	(blockId)->bi_hi = (blockNumber) >> 16, \
-	(blockId)->bi_lo = (blockNumber) & 0xffff \
-)
-
-/*
- * BlockIdCopy
- *		Copy a block identifier.
- */
-#define BlockIdCopy(toBlockId, fromBlockId) \
-( \
-	(toBlockId)->bi_hi = (fromBlockId)->bi_hi, \
-	(toBlockId)->bi_lo = (fromBlockId)->bi_lo \
-)
-
-/*
- * BlockIdEquals
- *		Check for block number equality.
- */
-#define BlockIdEquals(blockId1, blockId2) \
-	((blockId1)->bi_hi == (blockId2)->bi_hi && \
-	 (blockId1)->bi_lo == (blockId2)->bi_lo)
-
-/*
- * BlockIdGetBlockNumber
- *		Retrieve the block number from a block identifier.
- */
-#define BlockIdGetBlockNumber(blockId) \
-	((((BlockNumber) (blockId)->bi_hi) << 16) | ((BlockNumber) (blockId)->bi_lo))
-
-#endif							/* BLOCK_H */

data/ext/pg_query/include/storage/buf.h

@@ -1,46 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * buf.h
- *	  Basic buffer manager data types.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/buf.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef BUF_H
-#define BUF_H
-
-/*
- * Buffer identifiers.
- *
- * Zero is invalid, positive is the index of a shared buffer (1..NBuffers),
- * negative is the index of a local buffer (-1 .. -NLocBuffer).
- */
-typedef int Buffer;
-
-#define InvalidBuffer	0
-
-/*
- * BufferIsInvalid
- *		True iff the buffer is invalid.
- */
-#define BufferIsInvalid(buffer) ((buffer) == InvalidBuffer)
-
-/*
- * BufferIsLocal
- *		True iff the buffer is local (not visible to other backends).
- */
-#define BufferIsLocal(buffer)	((buffer) < 0)
-
-/*
- * Buffer access strategy objects.
- *
- * BufferAccessStrategyData is private to freelist.c
- */
-typedef struct BufferAccessStrategyData *BufferAccessStrategy;
-
-#endif							/* BUF_H */

data/ext/pg_query/include/storage/bufmgr.h

@@ -1,297 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * bufmgr.h
- *	  POSTGRES buffer manager definitions.
- *
- *
- * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/storage/bufmgr.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef BUFMGR_H
-#define BUFMGR_H
-
-#include "storage/block.h"
-#include "storage/buf.h"
-#include "storage/bufpage.h"
-#include "storage/relfilenode.h"
-#include "utils/relcache.h"
-#include "utils/snapmgr.h"
-
-typedef void *Block;
-
-/* Possible arguments for GetAccessStrategy() */
-typedef enum BufferAccessStrategyType
-{
-	BAS_NORMAL,					/* Normal random access */
-	BAS_BULKREAD,				/* Large read-only scan (hint bit updates are
-								 * ok) */
-	BAS_BULKWRITE,				/* Large multi-block write (e.g. COPY IN) */
-	BAS_VACUUM					/* VACUUM */
-} BufferAccessStrategyType;
-
-/* Possible modes for ReadBufferExtended() */
-typedef enum
-{
-	RBM_NORMAL,					/* Normal read */
-	RBM_ZERO_AND_LOCK,			/* Don't read from disk, caller will
-								 * initialize. Also locks the page. */
-	RBM_ZERO_AND_CLEANUP_LOCK,	/* Like RBM_ZERO_AND_LOCK, but locks the page
-								 * in "cleanup" mode */
-	RBM_ZERO_ON_ERROR,			/* Read, but return an all-zeros page on error */
-	RBM_NORMAL_NO_LOG			/* Don't log page as invalid during WAL
-								 * replay; otherwise same as RBM_NORMAL */
-} ReadBufferMode;
-
-/*
- * Type returned by PrefetchBuffer().
- */
-typedef struct PrefetchBufferResult
-{
-	Buffer		recent_buffer;	/* If valid, a hit (recheck needed!) */
-	bool		initiated_io;	/* If true, a miss resulting in async I/O */
-} PrefetchBufferResult;
-
-/* forward declared, to avoid having to expose buf_internals.h here */
-struct WritebackContext;
-
-/* forward declared, to avoid including smgr.h here */
-struct SMgrRelationData;
-
-/* in globals.c ... this duplicates miscadmin.h */
-extern PGDLLIMPORT int NBuffers;
-
-/* in bufmgr.c */
-extern PGDLLIMPORT bool zero_damaged_pages;
-extern PGDLLIMPORT int bgwriter_lru_maxpages;
-extern PGDLLIMPORT double bgwriter_lru_multiplier;
-extern PGDLLIMPORT bool track_io_timing;
-extern PGDLLIMPORT int effective_io_concurrency;
-extern PGDLLIMPORT int maintenance_io_concurrency;
-
-extern PGDLLIMPORT int checkpoint_flush_after;
-extern PGDLLIMPORT int backend_flush_after;
-extern PGDLLIMPORT int bgwriter_flush_after;
-
-/* in buf_init.c */
-extern PGDLLIMPORT char *BufferBlocks;
-
-/* in localbuf.c */
-extern PGDLLIMPORT int NLocBuffer;
-extern PGDLLIMPORT Block *LocalBufferBlockPointers;
-extern PGDLLIMPORT int32 *LocalRefCount;
-
-/* upper limit for effective_io_concurrency */
-#define MAX_IO_CONCURRENCY 1000
-
-/* special block number for ReadBuffer() */
-#define P_NEW	InvalidBlockNumber	/* grow the file to get a new page */
-
-/*
- * Buffer content lock modes (mode argument for LockBuffer())
- */
-#define BUFFER_LOCK_UNLOCK		0
-#define BUFFER_LOCK_SHARE		1
-#define BUFFER_LOCK_EXCLUSIVE	2
-
-/*
- * These routines are beaten on quite heavily, hence the macroization.
- */
-
-/*
- * BufferIsValid
- *		True iff the given buffer number is valid (either as a shared
- *		or local buffer).
- *
- * Note: For a long time this was defined the same as BufferIsPinned,
- * that is it would say False if you didn't hold a pin on the buffer.
- * I believe this was bogus and served only to mask logic errors.
- * Code should always know whether it has a buffer reference,
- * independently of the pin state.
- *
- * Note: For a further long time this was not quite the inverse of the
- * BufferIsInvalid() macro, in that it also did sanity checks to verify
- * that the buffer number was in range.  Most likely, this macro was
- * originally intended only to be used in assertions, but its use has
- * since expanded quite a bit, and the overhead of making those checks
- * even in non-assert-enabled builds can be significant.  Thus, we've
- * now demoted the range checks to assertions within the macro itself.
- */
-#define BufferIsValid(bufnum) \
-( \
-	AssertMacro((bufnum) <= NBuffers && (bufnum) >= -NLocBuffer), \
-	(bufnum) != InvalidBuffer  \
-)
-
-/*
- * BufferGetBlock
- *		Returns a reference to a disk page image associated with a buffer.
- *
- * Note:
- *		Assumes buffer is valid.
- */
-#define BufferGetBlock(buffer) \
-( \
-	AssertMacro(BufferIsValid(buffer)), \
-	BufferIsLocal(buffer) ? \
-		LocalBufferBlockPointers[-(buffer) - 1] \
-	: \
-		(Block) (BufferBlocks + ((Size) ((buffer) - 1)) * BLCKSZ) \
-)
-
-/*
- * BufferGetPageSize
- *		Returns the page size within a buffer.
- *
- * Notes:
- *		Assumes buffer is valid.
- *
- *		The buffer can be a raw disk block and need not contain a valid
- *		(formatted) disk page.
- */
-/* XXX should dig out of buffer descriptor */
-#define BufferGetPageSize(buffer) \
-( \
-	AssertMacro(BufferIsValid(buffer)), \
-	(Size)BLCKSZ \
-)
-
-/*
- * BufferGetPage
- *		Returns the page associated with a buffer.
- *
- * When this is called as part of a scan, there may be a need for a nearby
- * call to TestForOldSnapshot().  See the definition of that for details.
- */
-#define BufferGetPage(buffer) ((Page)BufferGetBlock(buffer))
-
-/*
- * prototypes for functions in bufmgr.c
- */
-extern PrefetchBufferResult PrefetchSharedBuffer(struct SMgrRelationData *smgr_reln,
-												 ForkNumber forkNum,
-												 BlockNumber blockNum);
-extern PrefetchBufferResult PrefetchBuffer(Relation reln, ForkNumber forkNum,
-										   BlockNumber blockNum);
-extern bool ReadRecentBuffer(RelFileNode rnode, ForkNumber forkNum,
-							 BlockNumber blockNum, Buffer recent_buffer);
-extern Buffer ReadBuffer(Relation reln, BlockNumber blockNum);
-extern Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum,
-								 BlockNumber blockNum, ReadBufferMode mode,
-								 BufferAccessStrategy strategy);
-extern Buffer ReadBufferWithoutRelcache(RelFileNode rnode,
-										ForkNumber forkNum, BlockNumber blockNum,
-										ReadBufferMode mode, BufferAccessStrategy strategy,
-										bool permanent);
-extern void ReleaseBuffer(Buffer buffer);
-extern void UnlockReleaseBuffer(Buffer buffer);
-extern void MarkBufferDirty(Buffer buffer);
-extern void IncrBufferRefCount(Buffer buffer);
-extern Buffer ReleaseAndReadBuffer(Buffer buffer, Relation relation,
-								   BlockNumber blockNum);
-
-extern void InitBufferPool(void);
-extern void InitBufferPoolAccess(void);
-extern void AtEOXact_Buffers(bool isCommit);
-extern void PrintBufferLeakWarning(Buffer buffer);
-extern void CheckPointBuffers(int flags);
-extern BlockNumber BufferGetBlockNumber(Buffer buffer);
-extern BlockNumber RelationGetNumberOfBlocksInFork(Relation relation,
-												   ForkNumber forkNum);
-extern void FlushOneBuffer(Buffer buffer);
-extern void FlushRelationBuffers(Relation rel);
-extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
-extern void CreateAndCopyRelationData(RelFileNode src_rnode,
-									  RelFileNode dst_rnode,
-									  bool permanent);
-extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
-								   int nforks, BlockNumber *firstDelBlock);
-extern void DropRelFileNodesAllBuffers(struct SMgrRelationData **smgr_reln, int nnodes);
-extern void DropDatabaseBuffers(Oid dbid);
-
-#define RelationGetNumberOfBlocks(reln) \
-	RelationGetNumberOfBlocksInFork(reln, MAIN_FORKNUM)
-
-extern bool BufferIsPermanent(Buffer buffer);
-extern XLogRecPtr BufferGetLSNAtomic(Buffer buffer);
-
-#ifdef NOT_USED
-extern void PrintPinnedBufs(void);
-#endif
-extern Size BufferShmemSize(void);
-extern void BufferGetTag(Buffer buffer, RelFileNode *rnode,
-						 ForkNumber *forknum, BlockNumber *blknum);
-
-extern void MarkBufferDirtyHint(Buffer buffer, bool buffer_std);
-
-extern void UnlockBuffers(void);
-extern void LockBuffer(Buffer buffer, int mode);
-extern bool ConditionalLockBuffer(Buffer buffer);
-extern void LockBufferForCleanup(Buffer buffer);
-extern bool ConditionalLockBufferForCleanup(Buffer buffer);
-extern bool IsBufferCleanupOK(Buffer buffer);
-extern bool HoldingBufferPinThatDelaysRecovery(void);
-
-extern void AbortBufferIO(void);
-
-extern void BufmgrCommit(void);
-extern bool BgBufferSync(struct WritebackContext *wb_context);
-
-extern void AtProcExit_LocalBuffers(void);
-
-extern void TestForOldSnapshot_impl(Snapshot snapshot, Relation relation);
-
-/* in freelist.c */
-extern BufferAccessStrategy GetAccessStrategy(BufferAccessStrategyType btype);
-extern void FreeAccessStrategy(BufferAccessStrategy strategy);
-
-
-/* inline functions */
-
-/*
- * Although this header file is nominally backend-only, certain frontend
- * programs like pg_waldump include it.  For compilers that emit static
- * inline functions even when they're unused, that leads to unsatisfied
- * external references; hence hide these with #ifndef FRONTEND.
- */
-
-#ifndef FRONTEND
-
-/*
- * Check whether the given snapshot is too old to have safely read the given
- * page from the given table.  If so, throw a "snapshot too old" error.
- *
- * This test generally needs to be performed after every BufferGetPage() call
- * that is executed as part of a scan.  It is not needed for calls made for
- * modifying the page (for example, to position to the right place to insert a
- * new index tuple or for vacuuming).  It may also be omitted where calls to
- * lower-level functions will have already performed the test.
- *
- * Note that a NULL snapshot argument is allowed and causes a fast return
- * without error; this is to support call sites which can be called from
- * either scans or index modification areas.
- *
- * For best performance, keep the tests that are fastest and/or most likely to
- * exclude a page from old snapshot testing near the front.
- */
-static inline void
-TestForOldSnapshot(Snapshot snapshot, Relation relation, Page page)
-{
-	Assert(relation != NULL);
-
-	if (old_snapshot_threshold >= 0
-		&& (snapshot) != NULL
-		&& ((snapshot)->snapshot_type == SNAPSHOT_MVCC
-			|| (snapshot)->snapshot_type == SNAPSHOT_TOAST)
-		&& !XLogRecPtrIsInvalid((snapshot)->lsn)
-		&& PageGetLSN(page) > (snapshot)->lsn)
-		TestForOldSnapshot_impl(snapshot, relation);
-}
-
-#endif							/* FRONTEND */
-
-#endif							/* BUFMGR_H */