pg_query 5.0.0 → 6.0.0

data/ext/pg_query/include/tcop/dest.h

@@ -1,147 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * dest.h
- *	  support for communication destinations
- *
- * Whenever the backend executes a query that returns tuples, the results
- * have to go someplace.  For example:
- *
- *	  - stdout is the destination only when we are running a
- *		standalone backend (no postmaster) and are returning results
- *		back to an interactive user.
- *
- *	  - a remote process is the destination when we are
- *		running a backend with a frontend and the frontend executes
- *		PQexec() or PQfn().  In this case, the results are sent
- *		to the frontend via the functions in backend/libpq.
- *
- *	  - DestNone is the destination when the system executes
- *		a query internally.  The results are discarded.
- *
- * dest.c defines three functions that implement destination management:
- *
- * BeginCommand: initialize the destination at start of command.
- * CreateDestReceiver: return a pointer to a struct of destination-specific
- * receiver functions.
- * EndCommand: clean up the destination at end of command.
- *
- * BeginCommand/EndCommand are executed once per received SQL query.
- *
- * CreateDestReceiver returns a receiver object appropriate to the specified
- * destination.  The executor, as well as utility statements that can return
- * tuples, are passed the resulting DestReceiver* pointer.  Each executor run
- * or utility execution calls the receiver's rStartup method, then the
- * receiveSlot method (zero or more times), then the rShutdown method.
- * The same receiver object may be re-used multiple times; eventually it is
- * destroyed by calling its rDestroy method.
- *
- * In some cases, receiver objects require additional parameters that must
- * be passed to them after calling CreateDestReceiver.  Since the set of
- * parameters varies for different receiver types, this is not handled by
- * this module, but by direct calls from the calling code to receiver type
- * specific functions.
- *
- * The DestReceiver object returned by CreateDestReceiver may be a statically
- * allocated object (for destination types that require no local state),
- * in which case rDestroy is a no-op.  Alternatively it can be a palloc'd
- * object that has DestReceiver as its first field and contains additional
- * fields (see printtup.c for an example).  These additional fields are then
- * accessible to the DestReceiver functions by casting the DestReceiver*
- * pointer passed to them.  The palloc'd object is pfree'd by the rDestroy
- * method.  Note that the caller of CreateDestReceiver should take care to
- * do so in a memory context that is long-lived enough for the receiver
- * object not to disappear while still needed.
- *
- * Special provision: None_Receiver is a permanently available receiver
- * object for the DestNone destination.  This avoids useless creation/destroy
- * calls in portal and cursor manipulations.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/tcop/dest.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef DEST_H
-#define DEST_H
-
-#include "executor/tuptable.h"
-#include "tcop/cmdtag.h"
-
-
-
-
-/* ----------------
- *		CommandDest is a simplistic means of identifying the desired
- *		destination.  Someday this will probably need to be improved.
- *
- * Note: only the values DestNone, DestDebug, DestRemote are legal for the
- * global variable whereToSendOutput.   The other values may be used
- * as the destination for individual commands.
- * ----------------
- */
-typedef enum
-{
-	DestNone,					/* results are discarded */
-	DestDebug,					/* results go to debugging output */
-	DestRemote,					/* results sent to frontend process */
-	DestRemoteExecute,			/* sent to frontend, in Execute command */
-	DestRemoteSimple,			/* sent to frontend, w/no catalog access */
-	DestSPI,					/* results sent to SPI manager */
-	DestTuplestore,				/* results sent to Tuplestore */
-	DestIntoRel,				/* results sent to relation (SELECT INTO) */
-	DestCopyOut,				/* results sent to COPY TO code */
-	DestSQLFunction,			/* results sent to SQL-language func mgr */
-	DestTransientRel,			/* results sent to transient relation */
-	DestTupleQueue				/* results sent to tuple queue */
-} CommandDest;
-
-/* ----------------
- *		DestReceiver is a base type for destination-specific local state.
- *		In the simplest cases, there is no state info, just the function
- *		pointers that the executor must call.
- *
- * Note: the receiveSlot routine must be passed a slot containing a TupleDesc
- * identical to the one given to the rStartup routine.  It returns bool where
- * a "true" value means "continue processing" and a "false" value means
- * "stop early, just as if we'd reached the end of the scan".
- * ----------------
- */
-typedef struct _DestReceiver DestReceiver;
-
-struct _DestReceiver
-{
-	/* Called for each tuple to be output: */
-	bool		(*receiveSlot) (TupleTableSlot *slot,
-								DestReceiver *self);
-	/* Per-executor-run initialization and shutdown: */
-	void		(*rStartup) (DestReceiver *self,
-							 int operation,
-							 TupleDesc typeinfo);
-	void		(*rShutdown) (DestReceiver *self);
-	/* Destroy the receiver object itself (if dynamically allocated) */
-	void		(*rDestroy) (DestReceiver *self);
-	/* CommandDest code for this receiver */
-	CommandDest mydest;
-	/* Private fields might appear beyond this point... */
-};
-
-extern PGDLLIMPORT DestReceiver *None_Receiver; /* permanent receiver for
-												 * DestNone */
-
-/* The primary destination management functions */
-
-extern void BeginCommand(CommandTag commandTag, CommandDest dest);
-extern DestReceiver *CreateDestReceiver(CommandDest dest);
-extern void EndCommand(const QueryCompletion *qc, CommandDest dest,
-					   bool force_undecorated_output);
-extern void EndReplicationCommand(const char *commandTag);
-
-/* Additional functions that go with destination management, more or less. */
-
-extern void NullCommand(CommandDest dest);
-extern void ReadyForQuery(CommandDest dest);
-
-#endif							/* DEST_H */

data/ext/pg_query/include/tcop/fastpath.h

@@ -1,20 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * fastpath.h
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/tcop/fastpath.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef FASTPATH_H
-#define FASTPATH_H
-
-#include "lib/stringinfo.h"
-
-extern void HandleFunctionRequest(StringInfo msgBuf);
-
-#endif							/* FASTPATH_H */

data/ext/pg_query/include/tcop/pquery.h

@@ -1,51 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * pquery.h
- *	  prototypes for pquery.c.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/tcop/pquery.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef PQUERY_H
-#define PQUERY_H
-
-#include "nodes/parsenodes.h"
-#include "utils/portal.h"
-
-struct PlannedStmt;				/* avoid including plannodes.h here */
-
-
-extern PGDLLIMPORT Portal ActivePortal;
-
-
-extern PortalStrategy ChoosePortalStrategy(List *stmts);
-
-extern List *FetchPortalTargetList(Portal portal);
-
-extern List *FetchStatementTargetList(Node *stmt);
-
-extern void PortalStart(Portal portal, ParamListInfo params,
-						int eflags, Snapshot snapshot);
-
-extern void PortalSetResultFormat(Portal portal, int nFormats,
-								  int16 *formats);
-
-extern bool PortalRun(Portal portal, long count, bool isTopLevel,
-					  bool run_once, DestReceiver *dest, DestReceiver *altdest,
-					  QueryCompletion *qc);
-
-extern uint64 PortalRunFetch(Portal portal,
-							 FetchDirection fdirection,
-							 long count,
-							 DestReceiver *dest);
-
-extern bool PlannedStmtRequiresSnapshot(struct PlannedStmt *pstmt);
-
-extern void EnsurePortalSnapshotExists(void);
-
-#endif							/* PQUERY_H */

data/ext/pg_query/include/tcop/tcopprot.h

@@ -1,94 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * tcopprot.h
- *	  prototypes for postgres.c.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/tcop/tcopprot.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef TCOPPROT_H
-#define TCOPPROT_H
-
-#include "nodes/params.h"
-#include "nodes/parsenodes.h"
-#include "nodes/plannodes.h"
-#include "storage/procsignal.h"
-#include "utils/guc.h"
-#include "utils/queryenvironment.h"
-
-
-/* Required daylight between max_stack_depth and the kernel limit, in bytes */
-#define STACK_DEPTH_SLOP (512 * 1024L)
-
-extern PGDLLIMPORT __thread  CommandDest whereToSendOutput;
-extern PGDLLIMPORT __thread const char *debug_query_string;
-extern PGDLLIMPORT __thread  int max_stack_depth;
-extern PGDLLIMPORT int PostAuthDelay;
-extern PGDLLIMPORT int client_connection_check_interval;
-
-/* GUC-configurable parameters */
-
-typedef enum
-{
-	LOGSTMT_NONE,				/* log no statements */
-	LOGSTMT_DDL,				/* log data definition statements */
-	LOGSTMT_MOD,				/* log modification statements, plus DDL */
-	LOGSTMT_ALL					/* log all statements */
-} LogStmtLevel;
-
-extern PGDLLIMPORT int log_statement;
-
-extern List *pg_parse_query(const char *query_string);
-extern List *pg_rewrite_query(Query *query);
-extern List *pg_analyze_and_rewrite_fixedparams(RawStmt *parsetree,
-												const char *query_string,
-												const Oid *paramTypes, int numParams,
-												QueryEnvironment *queryEnv);
-extern List *pg_analyze_and_rewrite_varparams(RawStmt *parsetree,
-											  const char *query_string,
-											  Oid **paramTypes,
-											  int *numParams,
-											  QueryEnvironment *queryEnv);
-extern List *pg_analyze_and_rewrite_withcb(RawStmt *parsetree,
-										   const char *query_string,
-										   ParserSetupHook parserSetup,
-										   void *parserSetupArg,
-										   QueryEnvironment *queryEnv);
-extern PlannedStmt *pg_plan_query(Query *querytree, const char *query_string,
-								  int cursorOptions,
-								  ParamListInfo boundParams);
-extern List *pg_plan_queries(List *querytrees, const char *query_string,
-							 int cursorOptions,
-							 ParamListInfo boundParams);
-
-extern void die(SIGNAL_ARGS);
-extern void quickdie(SIGNAL_ARGS) pg_attribute_noreturn();
-extern void StatementCancelHandler(SIGNAL_ARGS);
-extern void FloatExceptionHandler(SIGNAL_ARGS) pg_attribute_noreturn();
-extern void RecoveryConflictInterrupt(ProcSignalReason reason); /* called from SIGUSR1
-																 * handler */
-extern void ProcessClientReadInterrupt(bool blocked);
-extern void ProcessClientWriteInterrupt(bool blocked);
-
-extern void process_postgres_switches(int argc, char *argv[],
-									  GucContext ctx, const char **dbname);
-extern void PostgresSingleUserMain(int argc, char *argv[],
-								   const char *username) pg_attribute_noreturn();
-extern void PostgresMain(const char *dbname,
-						 const char *username) pg_attribute_noreturn();
-extern long get_stack_depth_rlimit(void);
-extern void ResetUsage(void);
-extern void ShowUsage(const char *title);
-extern int	check_log_duration(char *msec_str, bool was_logged);
-extern void set_debug_options(int debug_flag,
-							  GucContext context, GucSource source);
-extern bool set_plan_disabling_options(const char *arg,
-									   GucContext context, GucSource source);
-extern const char *get_stats_option_name(const char *arg);
-
-#endif							/* TCOPPROT_H */

data/ext/pg_query/include/tcop/utility.h

@@ -1,112 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * utility.h
- *	  prototypes for utility.c.
- *
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/tcop/utility.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef UTILITY_H
-#define UTILITY_H
-
-#include "tcop/cmdtag.h"
-#include "tcop/tcopprot.h"
-
-typedef enum
-{
-	PROCESS_UTILITY_TOPLEVEL,	/* toplevel interactive command */
-	PROCESS_UTILITY_QUERY,		/* a complete query, but not toplevel */
-	PROCESS_UTILITY_QUERY_NONATOMIC,	/* a complete query, nonatomic
-										 * execution context */
-	PROCESS_UTILITY_SUBCOMMAND	/* a portion of a query */
-} ProcessUtilityContext;
-
-/* Info needed when recursing from ALTER TABLE */
-typedef struct AlterTableUtilityContext
-{
-	PlannedStmt *pstmt;			/* PlannedStmt for outer ALTER TABLE command */
-	const char *queryString;	/* its query string */
-	Oid			relid;			/* OID of ALTER's target table */
-	ParamListInfo params;		/* any parameters available to ALTER TABLE */
-	QueryEnvironment *queryEnv; /* execution environment for ALTER TABLE */
-} AlterTableUtilityContext;
-
-/*
- * These constants are used to describe the extent to which a particular
- * command is read-only.
- *
- * COMMAND_OK_IN_READ_ONLY_TXN means that the command is permissible even when
- * XactReadOnly is set. This bit should be set for commands that don't change
- * the state of the database (data or schema) in a way that would affect the
- * output of pg_dump.
- *
- * COMMAND_OK_IN_PARALLEL_MODE means that the command is permissible even
- * when in parallel mode. Writing tuples is forbidden, as is anything that
- * might confuse cooperating processes.
- *
- * COMMAND_OK_IN_RECOVERY means that the command is permissible even when in
- * recovery. It can't write WAL, nor can it do things that would imperil
- * replay of future WAL received from the primary.
- */
-#define COMMAND_OK_IN_READ_ONLY_TXN	0x0001
-#define COMMAND_OK_IN_PARALLEL_MODE	0x0002
-#define	COMMAND_OK_IN_RECOVERY		0x0004
-
-/*
- * We say that a command is strictly read-only if it is sufficiently read-only
- * for all purposes. For clarity, we also have a constant for commands that are
- * in no way read-only.
- */
-#define COMMAND_IS_STRICTLY_READ_ONLY \
-	(COMMAND_OK_IN_READ_ONLY_TXN | COMMAND_OK_IN_RECOVERY | \
-	 COMMAND_OK_IN_PARALLEL_MODE)
-#define COMMAND_IS_NOT_READ_ONLY	0
-
-/* Hook for plugins to get control in ProcessUtility() */
-typedef void (*ProcessUtility_hook_type) (PlannedStmt *pstmt,
-										  const char *queryString,
-										  bool readOnlyTree,
-										  ProcessUtilityContext context,
-										  ParamListInfo params,
-										  QueryEnvironment *queryEnv,
-										  DestReceiver *dest, QueryCompletion *qc);
-extern PGDLLIMPORT ProcessUtility_hook_type ProcessUtility_hook;
-
-extern void ProcessUtility(PlannedStmt *pstmt, const char *queryString,
-						   bool readOnlyTree,
-						   ProcessUtilityContext context, ParamListInfo params,
-						   QueryEnvironment *queryEnv,
-						   DestReceiver *dest, QueryCompletion *qc);
-extern void standard_ProcessUtility(PlannedStmt *pstmt, const char *queryString,
-									bool readOnlyTree,
-									ProcessUtilityContext context, ParamListInfo params,
-									QueryEnvironment *queryEnv,
-									DestReceiver *dest, QueryCompletion *qc);
-
-extern void ProcessUtilityForAlterTable(Node *stmt,
-										AlterTableUtilityContext *context);
-
-extern bool UtilityReturnsTuples(Node *parsetree);
-
-extern TupleDesc UtilityTupleDescriptor(Node *parsetree);
-
-extern Query *UtilityContainsQuery(Node *parsetree);
-
-extern CommandTag CreateCommandTag(Node *parsetree);
-
-static inline const char *
-CreateCommandName(Node *parsetree)
-{
-	return GetCommandTagName(CreateCommandTag(parsetree));
-}
-
-extern LogStmtLevel GetCommandLogLevel(Node *parsetree);
-
-extern bool CommandIsReadOnly(PlannedStmt *pstmt);
-
-#endif							/* UTILITY_H */

data/ext/pg_query/include/tsearch/ts_cache.h

@@ -1,96 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * ts_cache.h
- *	  Tsearch related object caches.
- *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/tsearch/ts_cache.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef TS_CACHE_H
-#define TS_CACHE_H
-
-#include "fmgr.h"
-
-
-/*
- * All TS*CacheEntry structs must share this common header
- * (see InvalidateTSCacheCallBack)
- */
-typedef struct TSAnyCacheEntry
-{
-	Oid			objId;
-	bool		isvalid;
-} TSAnyCacheEntry;
-
-
-typedef struct TSParserCacheEntry
-{
-	/* prsId is the hash lookup key and MUST BE FIRST */
-	Oid			prsId;			/* OID of the parser */
-	bool		isvalid;
-
-	Oid			startOid;
-	Oid			tokenOid;
-	Oid			endOid;
-	Oid			headlineOid;
-	Oid			lextypeOid;
-
-	/*
-	 * Pre-set-up fmgr call of most needed parser's methods
-	 */
-	FmgrInfo	prsstart;
-	FmgrInfo	prstoken;
-	FmgrInfo	prsend;
-	FmgrInfo	prsheadline;
-} TSParserCacheEntry;
-
-typedef struct TSDictionaryCacheEntry
-{
-	/* dictId is the hash lookup key and MUST BE FIRST */
-	Oid			dictId;
-	bool		isvalid;
-
-	/* most frequent fmgr call */
-	Oid			lexizeOid;
-	FmgrInfo	lexize;
-
-	MemoryContext dictCtx;		/* memory context to store private data */
-	void	   *dictData;
-} TSDictionaryCacheEntry;
-
-typedef struct
-{
-	int			len;
-	Oid		   *dictIds;
-} ListDictionary;
-
-typedef struct
-{
-	/* cfgId is the hash lookup key and MUST BE FIRST */
-	Oid			cfgId;
-	bool		isvalid;
-
-	Oid			prsId;
-
-	int			lenmap;
-	ListDictionary *map;
-} TSConfigCacheEntry;
-
-
-/*
- * GUC variable for current configuration
- */
-extern PGDLLIMPORT char *TSCurrentConfig;
-
-
-extern TSParserCacheEntry *lookup_ts_parser_cache(Oid prsId);
-extern TSDictionaryCacheEntry *lookup_ts_dictionary_cache(Oid dictId);
-extern TSConfigCacheEntry *lookup_ts_config_cache(Oid cfgId);
-
-extern Oid	getTSCurrentConfig(bool emitError);
-
-#endif							/* TS_CACHE_H */