pg_query 5.0.0 → 6.0.0

data/ext/pg_query/include/utils/pidfile.h

@@ -1,56 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pidfile.h
- *	  Declarations describing the data directory lock file (postmaster.pid)
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/pidfile.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef UTILS_PIDFILE_H
-#define UTILS_PIDFILE_H
-
-/*
- * As of Postgres 10, the contents of the data-directory lock file are:
- *
- * line #
- *		1	postmaster PID (or negative of a standalone backend's PID)
- *		2	data directory path
- *		3	postmaster start timestamp (time_t representation)
- *		4	port number
- *		5	first Unix socket directory path (empty if none)
- *		6	first listen_address (IP address or "*"; empty if no TCP port)
- *		7	shared memory key (empty on Windows)
- *		8	postmaster status (see values below)
- *
- * Lines 6 and up are added via AddToDataDirLockFile() after initial file
- * creation; also, line 5 is initially empty and is changed after the first
- * Unix socket is opened.  Onlookers should not assume that lines 4 and up
- * are filled in any particular order.
- *
- * Socket lock file(s), if used, have the same contents as lines 1-5, with
- * line 5 being their own directory.
- */
-#define LOCK_FILE_LINE_PID			1
-#define LOCK_FILE_LINE_DATA_DIR		2
-#define LOCK_FILE_LINE_START_TIME	3
-#define LOCK_FILE_LINE_PORT			4
-#define LOCK_FILE_LINE_SOCKET_DIR	5
-#define LOCK_FILE_LINE_LISTEN_ADDR	6
-#define LOCK_FILE_LINE_SHMEM_KEY	7
-#define LOCK_FILE_LINE_PM_STATUS	8
-
-/*
- * The PM_STATUS line may contain one of these values.  All these strings
- * must be the same length, per comments for AddToDataDirLockFile().
- * We pad with spaces as needed to make that true.
- */
-#define PM_STATUS_STARTING		"starting"	/* still starting up */
-#define PM_STATUS_STOPPING		"stopping"	/* in shutdown sequence */
-#define PM_STATUS_READY			"ready   "	/* ready for connections */
-#define PM_STATUS_STANDBY		"standby "	/* up, won't accept connections */
-
-#endif							/* UTILS_PIDFILE_H */

data/ext/pg_query/include/utils/plancache.h

@@ -1,236 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * plancache.h
- *	  Plan cache definitions.
- *
- * See plancache.c for comments.
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/plancache.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PLANCACHE_H
-#define PLANCACHE_H
-
-#include "access/tupdesc.h"
-#include "lib/ilist.h"
-#include "nodes/params.h"
-#include "tcop/cmdtag.h"
-#include "utils/queryenvironment.h"
-#include "utils/resowner.h"
-
-
-/* Forward declaration, to avoid including parsenodes.h here */
-struct RawStmt;
-
-/* possible values for plan_cache_mode */
-typedef enum
-{
-	PLAN_CACHE_MODE_AUTO,
-	PLAN_CACHE_MODE_FORCE_GENERIC_PLAN,
-	PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN
-}			PlanCacheMode;
-
-/* GUC parameter */
-extern PGDLLIMPORT int plan_cache_mode;
-
-#define CACHEDPLANSOURCE_MAGIC		195726186
-#define CACHEDPLAN_MAGIC			953717834
-#define CACHEDEXPR_MAGIC			838275847
-
-/*
- * CachedPlanSource (which might better have been called CachedQuery)
- * represents a SQL query that we expect to use multiple times.  It stores
- * the query source text, the raw parse tree, and the analyzed-and-rewritten
- * query tree, as well as adjunct data.  Cache invalidation can happen as a
- * result of DDL affecting objects used by the query.  In that case we discard
- * the analyzed-and-rewritten query tree, and rebuild it when next needed.
- *
- * An actual execution plan, represented by CachedPlan, is derived from the
- * CachedPlanSource when we need to execute the query.  The plan could be
- * either generic (usable with any set of plan parameters) or custom (for a
- * specific set of parameters).  plancache.c contains the logic that decides
- * which way to do it for any particular execution.  If we are using a generic
- * cached plan then it is meant to be re-used across multiple executions, so
- * callers must always treat CachedPlans as read-only.
- *
- * Once successfully built and "saved", CachedPlanSources typically live
- * for the life of the backend, although they can be dropped explicitly.
- * CachedPlans are reference-counted and go away automatically when the last
- * reference is dropped.  A CachedPlan can outlive the CachedPlanSource it
- * was created from.
- *
- * An "unsaved" CachedPlanSource can be used for generating plans, but it
- * lives in transient storage and will not be updated in response to sinval
- * events.
- *
- * CachedPlans made from saved CachedPlanSources are likewise in permanent
- * storage, so to avoid memory leaks, the reference-counted references to them
- * must be held in permanent data structures or ResourceOwners.  CachedPlans
- * made from unsaved CachedPlanSources are in children of the caller's
- * memory context, so references to them should not be longer-lived than
- * that context.  (Reference counting is somewhat pro forma in that case,
- * though it may be useful if the CachedPlan can be discarded early.)
- *
- * A CachedPlanSource has two associated memory contexts: one that holds the
- * struct itself, the query source text and the raw parse tree, and another
- * context that holds the rewritten query tree and associated data.  This
- * allows the query tree to be discarded easily when it is invalidated.
- *
- * Some callers wish to use the CachedPlan API even with one-shot queries
- * that have no reason to be saved at all.  We therefore support a "oneshot"
- * variant that does no data copying or invalidation checking.  In this case
- * there are no separate memory contexts: the CachedPlanSource struct and
- * all subsidiary data live in the caller's CurrentMemoryContext, and there
- * is no way to free memory short of clearing that entire context.  A oneshot
- * plan is always treated as unsaved.
- *
- * Note: the string referenced by commandTag is not subsidiary storage;
- * it is assumed to be a compile-time-constant string.  As with portals,
- * commandTag shall be NULL if and only if the original query string (before
- * rewriting) was an empty string.
- */
-typedef struct CachedPlanSource
-{
-	int			magic;			/* should equal CACHEDPLANSOURCE_MAGIC */
-	struct RawStmt *raw_parse_tree; /* output of raw_parser(), or NULL */
-	const char *query_string;	/* source text of query */
-	CommandTag	commandTag;		/* 'nuff said */
-	Oid		   *param_types;	/* array of parameter type OIDs, or NULL */
-	int			num_params;		/* length of param_types array */
-	ParserSetupHook parserSetup;	/* alternative parameter spec method */
-	void	   *parserSetupArg;
-	int			cursor_options; /* cursor options used for planning */
-	bool		fixed_result;	/* disallow change in result tupdesc? */
-	TupleDesc	resultDesc;		/* result type; NULL = doesn't return tuples */
-	MemoryContext context;		/* memory context holding all above */
-	/* These fields describe the current analyzed-and-rewritten query tree: */
-	List	   *query_list;		/* list of Query nodes, or NIL if not valid */
-	List	   *relationOids;	/* OIDs of relations the queries depend on */
-	List	   *invalItems;		/* other dependencies, as PlanInvalItems */
-	struct OverrideSearchPath *search_path; /* search_path used for parsing
-											 * and planning */
-	MemoryContext query_context;	/* context holding the above, or NULL */
-	Oid			rewriteRoleId;	/* Role ID we did rewriting for */
-	bool		rewriteRowSecurity; /* row_security used during rewrite */
-	bool		dependsOnRLS;	/* is rewritten query specific to the above? */
-	/* If we have a generic plan, this is a reference-counted link to it: */
-	struct CachedPlan *gplan;	/* generic plan, or NULL if not valid */
-	/* Some state flags: */
-	bool		is_oneshot;		/* is it a "oneshot" plan? */
-	bool		is_complete;	/* has CompleteCachedPlan been done? */
-	bool		is_saved;		/* has CachedPlanSource been "saved"? */
-	bool		is_valid;		/* is the query_list currently valid? */
-	int			generation;		/* increments each time we create a plan */
-	/* If CachedPlanSource has been saved, it is a member of a global list */
-	dlist_node	node;			/* list link, if is_saved */
-	/* State kept to help decide whether to use custom or generic plans: */
-	double		generic_cost;	/* cost of generic plan, or -1 if not known */
-	double		total_custom_cost;	/* total cost of custom plans so far */
-	int64		num_custom_plans;	/* # of custom plans included in total */
-	int64		num_generic_plans;	/* # of generic plans */
-} CachedPlanSource;
-
-/*
- * CachedPlan represents an execution plan derived from a CachedPlanSource.
- * The reference count includes both the link from the parent CachedPlanSource
- * (if any), and any active plan executions, so the plan can be discarded
- * exactly when refcount goes to zero.  Both the struct itself and the
- * subsidiary data live in the context denoted by the context field.
- * This makes it easy to free a no-longer-needed cached plan.  (However,
- * if is_oneshot is true, the context does not belong solely to the CachedPlan
- * so no freeing is possible.)
- */
-typedef struct CachedPlan
-{
-	int			magic;			/* should equal CACHEDPLAN_MAGIC */
-	List	   *stmt_list;		/* list of PlannedStmts */
-	bool		is_oneshot;		/* is it a "oneshot" plan? */
-	bool		is_saved;		/* is CachedPlan in a long-lived context? */
-	bool		is_valid;		/* is the stmt_list currently valid? */
-	Oid			planRoleId;		/* Role ID the plan was created for */
-	bool		dependsOnRole;	/* is plan specific to that role? */
-	TransactionId saved_xmin;	/* if valid, replan when TransactionXmin
-								 * changes from this value */
-	int			generation;		/* parent's generation number for this plan */
-	int			refcount;		/* count of live references to this struct */
-	MemoryContext context;		/* context containing this CachedPlan */
-} CachedPlan;
-
-/*
- * CachedExpression is a low-overhead mechanism for caching the planned form
- * of standalone scalar expressions.  While such expressions are not usually
- * subject to cache invalidation events, that can happen, for example because
- * of replacement of a SQL function that was inlined into the expression.
- * The plancache takes care of storing the expression tree and marking it
- * invalid if a cache invalidation occurs, but the caller must notice the
- * !is_valid status and discard the obsolete expression without reusing it.
- * We do not store the original parse tree, only the planned expression;
- * this is an optimization based on the assumption that we usually will not
- * need to replan for the life of the session.
- */
-typedef struct CachedExpression
-{
-	int			magic;			/* should equal CACHEDEXPR_MAGIC */
-	Node	   *expr;			/* planned form of expression */
-	bool		is_valid;		/* is the expression still valid? */
-	/* remaining fields should be treated as private to plancache.c: */
-	List	   *relationOids;	/* OIDs of relations the expr depends on */
-	List	   *invalItems;		/* other dependencies, as PlanInvalItems */
-	MemoryContext context;		/* context containing this CachedExpression */
-	dlist_node	node;			/* link in global list of CachedExpressions */
-} CachedExpression;
-
-
-extern void InitPlanCache(void);
-extern void ResetPlanCache(void);
-
-extern CachedPlanSource *CreateCachedPlan(struct RawStmt *raw_parse_tree,
-										  const char *query_string,
-										  CommandTag commandTag);
-extern CachedPlanSource *CreateOneShotCachedPlan(struct RawStmt *raw_parse_tree,
-												 const char *query_string,
-												 CommandTag commandTag);
-extern void CompleteCachedPlan(CachedPlanSource *plansource,
-							   List *querytree_list,
-							   MemoryContext querytree_context,
-							   Oid *param_types,
-							   int num_params,
-							   ParserSetupHook parserSetup,
-							   void *parserSetupArg,
-							   int cursor_options,
-							   bool fixed_result);
-
-extern void SaveCachedPlan(CachedPlanSource *plansource);
-extern void DropCachedPlan(CachedPlanSource *plansource);
-
-extern void CachedPlanSetParentContext(CachedPlanSource *plansource,
-									   MemoryContext newcontext);
-
-extern CachedPlanSource *CopyCachedPlan(CachedPlanSource *plansource);
-
-extern bool CachedPlanIsValid(CachedPlanSource *plansource);
-
-extern List *CachedPlanGetTargetList(CachedPlanSource *plansource,
-									 QueryEnvironment *queryEnv);
-
-extern CachedPlan *GetCachedPlan(CachedPlanSource *plansource,
-								 ParamListInfo boundParams,
-								 ResourceOwner owner,
-								 QueryEnvironment *queryEnv);
-extern void ReleaseCachedPlan(CachedPlan *plan, ResourceOwner owner);
-
-extern bool CachedPlanAllowsSimpleValidityCheck(CachedPlanSource *plansource,
-												CachedPlan *plan,
-												ResourceOwner owner);
-extern bool CachedPlanIsSimplyValid(CachedPlanSource *plansource,
-									CachedPlan *plan,
-									ResourceOwner owner);
-
-extern CachedExpression *GetCachedExpression(Node *expr);
-extern void FreeCachedExpression(CachedExpression *cexpr);
-
-#endif							/* PLANCACHE_H */

data/ext/pg_query/include/utils/portal.h

@@ -1,252 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * portal.h
- *	  POSTGRES portal definitions.
- *
- * A portal is an abstraction which represents the execution state of
- * a running or runnable query.  Portals support both SQL-level CURSORs
- * and protocol-level portals.
- *
- * Scrolling (nonsequential access) and suspension of execution are allowed
- * only for portals that contain a single SELECT-type query.  We do not want
- * to let the client suspend an update-type query partway through!	Because
- * the query rewriter does not allow arbitrary ON SELECT rewrite rules,
- * only queries that were originally update-type could produce multiple
- * plan trees; so the restriction to a single query is not a problem
- * in practice.
- *
- * For SQL cursors, we support three kinds of scroll behavior:
- *
- * (1) Neither NO SCROLL nor SCROLL was specified: to remain backward
- *	   compatible, we allow backward fetches here, unless it would
- *	   impose additional runtime overhead to do so.
- *
- * (2) NO SCROLL was specified: don't allow any backward fetches.
- *
- * (3) SCROLL was specified: allow all kinds of backward fetches, even
- *	   if we need to take a performance hit to do so.  (The planner sticks
- *	   a Materialize node atop the query plan if needed.)
- *
- * Case #1 is converted to #2 or #3 by looking at the query itself and
- * determining if scrollability can be supported without additional
- * overhead.
- *
- * Protocol-level portals have no nonsequential-fetch API and so the
- * distinction doesn't matter for them.  They are always initialized
- * to look like NO SCROLL cursors.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/portal.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PORTAL_H
-#define PORTAL_H
-
-#include "datatype/timestamp.h"
-#include "executor/execdesc.h"
-#include "tcop/cmdtag.h"
-#include "utils/plancache.h"
-#include "utils/resowner.h"
-
-/*
- * We have several execution strategies for Portals, depending on what
- * query or queries are to be executed.  (Note: in all cases, a Portal
- * executes just a single source-SQL query, and thus produces just a
- * single result from the user's viewpoint.  However, the rule rewriter
- * may expand the single source query to zero or many actual queries.)
- *
- * PORTAL_ONE_SELECT: the portal contains one single SELECT query.  We run
- * the Executor incrementally as results are demanded.  This strategy also
- * supports holdable cursors (the Executor results can be dumped into a
- * tuplestore for access after transaction completion).
- *
- * PORTAL_ONE_RETURNING: the portal contains a single INSERT/UPDATE/DELETE
- * query with a RETURNING clause (plus possibly auxiliary queries added by
- * rule rewriting).  On first execution, we run the portal to completion
- * and dump the primary query's results into the portal tuplestore; the
- * results are then returned to the client as demanded.  (We can't support
- * suspension of the query partway through, because the AFTER TRIGGER code
- * can't cope, and also because we don't want to risk failing to execute
- * all the auxiliary queries.)
- *
- * PORTAL_ONE_MOD_WITH: the portal contains one single SELECT query, but
- * it has data-modifying CTEs.  This is currently treated the same as the
- * PORTAL_ONE_RETURNING case because of the possibility of needing to fire
- * triggers.  It may act more like PORTAL_ONE_SELECT in future.
- *
- * PORTAL_UTIL_SELECT: the portal contains a utility statement that returns
- * a SELECT-like result (for example, EXPLAIN or SHOW).  On first execution,
- * we run the statement and dump its results into the portal tuplestore;
- * the results are then returned to the client as demanded.
- *
- * PORTAL_MULTI_QUERY: all other cases.  Here, we do not support partial
- * execution: the portal's queries will be run to completion on first call.
- */
-typedef enum PortalStrategy
-{
-	PORTAL_ONE_SELECT,
-	PORTAL_ONE_RETURNING,
-	PORTAL_ONE_MOD_WITH,
-	PORTAL_UTIL_SELECT,
-	PORTAL_MULTI_QUERY
-} PortalStrategy;
-
-/*
- * A portal is always in one of these states.  It is possible to transit
- * from ACTIVE back to READY if the query is not run to completion;
- * otherwise we never back up in status.
- */
-typedef enum PortalStatus
-{
-	PORTAL_NEW,					/* freshly created */
-	PORTAL_DEFINED,				/* PortalDefineQuery done */
-	PORTAL_READY,				/* PortalStart complete, can run it */
-	PORTAL_ACTIVE,				/* portal is running (can't delete it) */
-	PORTAL_DONE,				/* portal is finished (don't re-run it) */
-	PORTAL_FAILED				/* portal got error (can't re-run it) */
-} PortalStatus;
-
-typedef struct PortalData *Portal;
-
-typedef struct PortalData
-{
-	/* Bookkeeping data */
-	const char *name;			/* portal's name */
-	const char *prepStmtName;	/* source prepared statement (NULL if none) */
-	MemoryContext portalContext;	/* subsidiary memory for portal */
-	ResourceOwner resowner;		/* resources owned by portal */
-	void		(*cleanup) (Portal portal); /* cleanup hook */
-
-	/*
-	 * State data for remembering which subtransaction(s) the portal was
-	 * created or used in.  If the portal is held over from a previous
-	 * transaction, both subxids are InvalidSubTransactionId.  Otherwise,
-	 * createSubid is the creating subxact and activeSubid is the last subxact
-	 * in which we ran the portal.
-	 */
-	SubTransactionId createSubid;	/* the creating subxact */
-	SubTransactionId activeSubid;	/* the last subxact with activity */
-	int			createLevel;	/* creating subxact's nesting level */
-
-	/* The query or queries the portal will execute */
-	const char *sourceText;		/* text of query (as of 8.4, never NULL) */
-	CommandTag	commandTag;		/* command tag for original query */
-	QueryCompletion qc;			/* command completion data for executed query */
-	List	   *stmts;			/* list of PlannedStmts */
-	CachedPlan *cplan;			/* CachedPlan, if stmts are from one */
-
-	ParamListInfo portalParams; /* params to pass to query */
-	QueryEnvironment *queryEnv; /* environment for query */
-
-	/* Features/options */
-	PortalStrategy strategy;	/* see above */
-	int			cursorOptions;	/* DECLARE CURSOR option bits */
-	bool		run_once;		/* portal will only be run once */
-
-	/* Status data */
-	PortalStatus status;		/* see above */
-	bool		portalPinned;	/* a pinned portal can't be dropped */
-	bool		autoHeld;		/* was automatically converted from pinned to
-								 * held (see HoldPinnedPortals()) */
-
-	/* If not NULL, Executor is active; call ExecutorEnd eventually: */
-	QueryDesc  *queryDesc;		/* info needed for executor invocation */
-
-	/* If portal returns tuples, this is their tupdesc: */
-	TupleDesc	tupDesc;		/* descriptor for result tuples */
-	/* and these are the format codes to use for the columns: */
-	int16	   *formats;		/* a format code for each column */
-
-	/*
-	 * Outermost ActiveSnapshot for execution of the portal's queries.  For
-	 * all but a few utility commands, we require such a snapshot to exist.
-	 * This ensures that TOAST references in query results can be detoasted,
-	 * and helps to reduce thrashing of the process's exposed xmin.
-	 */
-	Snapshot	portalSnapshot; /* active snapshot, or NULL if none */
-
-	/*
-	 * Where we store tuples for a held cursor or a PORTAL_ONE_RETURNING or
-	 * PORTAL_UTIL_SELECT query.  (A cursor held past the end of its
-	 * transaction no longer has any active executor state.)
-	 */
-	Tuplestorestate *holdStore; /* store for holdable cursors */
-	MemoryContext holdContext;	/* memory containing holdStore */
-
-	/*
-	 * Snapshot under which tuples in the holdStore were read.  We must keep a
-	 * reference to this snapshot if there is any possibility that the tuples
-	 * contain TOAST references, because releasing the snapshot could allow
-	 * recently-dead rows to be vacuumed away, along with any toast data
-	 * belonging to them.  In the case of a held cursor, we avoid needing to
-	 * keep such a snapshot by forcibly detoasting the data.
-	 */
-	Snapshot	holdSnapshot;	/* registered snapshot, or NULL if none */
-
-	/*
-	 * atStart, atEnd and portalPos indicate the current cursor position.
-	 * portalPos is zero before the first row, N after fetching N'th row of
-	 * query.  After we run off the end, portalPos = # of rows in query, and
-	 * atEnd is true.  Note that atStart implies portalPos == 0, but not the
-	 * reverse: we might have backed up only as far as the first row, not to
-	 * the start.  Also note that various code inspects atStart and atEnd, but
-	 * only the portal movement routines should touch portalPos.
-	 */
-	bool		atStart;
-	bool		atEnd;
-	uint64		portalPos;
-
-	/* Presentation data, primarily used by the pg_cursors system view */
-	TimestampTz creation_time;	/* time at which this portal was defined */
-	bool		visible;		/* include this portal in pg_cursors? */
-}			PortalData;
-
-/*
- * PortalIsValid
- *		True iff portal is valid.
- */
-#define PortalIsValid(p) PointerIsValid(p)
-
-
-/* Prototypes for functions in utils/mmgr/portalmem.c */
-extern void EnablePortalManager(void);
-extern bool PreCommit_Portals(bool isPrepare);
-extern void AtAbort_Portals(void);
-extern void AtCleanup_Portals(void);
-extern void PortalErrorCleanup(void);
-extern void AtSubCommit_Portals(SubTransactionId mySubid,
-								SubTransactionId parentSubid,
-								int parentLevel,
-								ResourceOwner parentXactOwner);
-extern void AtSubAbort_Portals(SubTransactionId mySubid,
-							   SubTransactionId parentSubid,
-							   ResourceOwner myXactOwner,
-							   ResourceOwner parentXactOwner);
-extern void AtSubCleanup_Portals(SubTransactionId mySubid);
-extern Portal CreatePortal(const char *name, bool allowDup, bool dupSilent);
-extern Portal CreateNewPortal(void);
-extern void PinPortal(Portal portal);
-extern void UnpinPortal(Portal portal);
-extern void MarkPortalActive(Portal portal);
-extern void MarkPortalDone(Portal portal);
-extern void MarkPortalFailed(Portal portal);
-extern void PortalDrop(Portal portal, bool isTopCommit);
-extern Portal GetPortalByName(const char *name);
-extern void PortalDefineQuery(Portal portal,
-							  const char *prepStmtName,
-							  const char *sourceText,
-							  CommandTag commandTag,
-							  List *stmts,
-							  CachedPlan *cplan);
-extern PlannedStmt *PortalGetPrimaryStmt(Portal portal);
-extern void PortalCreateHoldStore(Portal portal);
-extern void PortalHashTableDeleteAll(void);
-extern bool ThereAreNoReadyPortals(void);
-extern void HoldPinnedPortals(void);
-extern void ForgetPortalSnapshots(void);
-
-#endif							/* PORTAL_H */

data/ext/pg_query/include/utils/queryenvironment.h

@@ -1,74 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * queryenvironment.h
- *	  Access to functions to mutate the query environment and retrieve the
- *	  actual data related to entries (if any).
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/queryenvironment.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef QUERYENVIRONMENT_H
-#define QUERYENVIRONMENT_H
-
-#include "access/tupdesc.h"
-
-
-typedef enum EphemeralNameRelationType
-{
-	ENR_NAMED_TUPLESTORE		/* named tuplestore relation; e.g., deltas */
-} EphemeralNameRelationType;
-
-/*
- * Some ephemeral named relations must match some relation (e.g., trigger
- * transition tables), so to properly handle cached plans and DDL, we should
- * carry the OID of that relation.  In other cases an ENR might be independent
- * of any relation which is stored in the system catalogs, so we need to be
- * able to directly store the TupleDesc.  We never need both.
- */
-typedef struct EphemeralNamedRelationMetadataData
-{
-	char	   *name;			/* name used to identify the relation */
-
-	/* only one of the next two fields should be used */
-	Oid			reliddesc;		/* oid of relation to get tupdesc */
-	TupleDesc	tupdesc;		/* description of result rows */
-
-	EphemeralNameRelationType enrtype;	/* to identify type of relation */
-	double		enrtuples;		/* estimated number of tuples */
-} EphemeralNamedRelationMetadataData;
-
-typedef EphemeralNamedRelationMetadataData *EphemeralNamedRelationMetadata;
-
-/*
- * Ephemeral Named Relation data; used for parsing named relations not in the
- * catalog, like transition tables in AFTER triggers.
- */
-typedef struct EphemeralNamedRelationData
-{
-	EphemeralNamedRelationMetadataData md;
-	void	   *reldata;		/* structure for execution-time access to data */
-} EphemeralNamedRelationData;
-
-typedef EphemeralNamedRelationData *EphemeralNamedRelation;
-
-/*
- * This is an opaque structure outside of queryenvironment.c itself.  The
- * intention is to be able to change the implementation or add new context
- * features without needing to change existing code for use of existing
- * features.
- */
-typedef struct QueryEnvironment QueryEnvironment;
-
-
-extern QueryEnvironment *create_queryEnv(void);
-extern EphemeralNamedRelationMetadata get_visible_ENR_metadata(QueryEnvironment *queryEnv, const char *refname);
-extern void register_ENR(QueryEnvironment *queryEnv, EphemeralNamedRelation enr);
-extern void unregister_ENR(QueryEnvironment *queryEnv, const char *name);
-extern EphemeralNamedRelation get_ENR(QueryEnvironment *queryEnv, const char *name);
-extern TupleDesc ENRMetadataGetTupDesc(EphemeralNamedRelationMetadata enrmd);
-
-#endif							/* QUERYENVIRONMENT_H */

data/ext/pg_query/include/utils/regproc.h

@@ -1,39 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * regproc.h
- *	  Functions for the built-in types regproc, regclass, regtype, etc.
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/utils/regproc.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef REGPROC_H
-#define REGPROC_H
-
-#include "nodes/pg_list.h"
-
-/* Control flags for format_procedure_extended */
-#define FORMAT_PROC_INVALID_AS_NULL	0x01	/* NULL if undefined */
-#define FORMAT_PROC_FORCE_QUALIFY	0x02	/* force qualification */
-extern char *format_procedure_extended(Oid procedure_oid, bits16 flags);
-
-/* Control flags for format_operator_extended */
-#define FORMAT_OPERATOR_INVALID_AS_NULL	0x01	/* NULL if undefined */
-#define FORMAT_OPERATOR_FORCE_QUALIFY	0x02	/* force qualification */
-extern char *format_operator_extended(Oid operator_oid, bits16 flags);
-
-extern List *stringToQualifiedNameList(const char *string, Node *escontext);
-extern char *format_procedure(Oid procedure_oid);
-extern char *format_procedure_qualified(Oid procedure_oid);
-extern void format_procedure_parts(Oid procedure_oid, List **objnames,
-								   List **objargs, bool missing_ok);
-
-extern char *format_operator(Oid operator_oid);
-extern char *format_operator_qualified(Oid operator_oid);
-extern void format_operator_parts(Oid operator_oid, List **objnames,
-								  List **objargs, bool missing_ok);
-
-#endif