embedded-postgres 18.6.0__py3-none-win_amd64.whl

embedded_postgres/pginstall/include/server/executor/nodeSort.h

@@ -0,0 +1,32 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeSort.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeSort.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODESORT_H
+#define NODESORT_H
+
+#include "access/parallel.h"
+#include "nodes/execnodes.h"
+
+extern SortState *ExecInitSort(Sort *node, EState *estate, int eflags);
+extern void ExecEndSort(SortState *node);
+extern void ExecSortMarkPos(SortState *node);
+extern void ExecSortRestrPos(SortState *node);
+extern void ExecReScanSort(SortState *node);
+
+/* parallel instrumentation support */
+extern void ExecSortEstimate(SortState *node, ParallelContext *pcxt);
+extern void ExecSortInitializeDSM(SortState *node, ParallelContext *pcxt);
+extern void ExecSortInitializeWorker(SortState *node, ParallelWorkerContext *pwcxt);
+extern void ExecSortRetrieveInstrumentation(SortState *node);
+
+#endif							/* NODESORT_H */

embedded_postgres/pginstall/include/server/executor/nodeSubplan.h

@@ -0,0 +1,29 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeSubplan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeSubplan.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODESUBPLAN_H
+#define NODESUBPLAN_H
+
+#include "nodes/execnodes.h"
+
+extern SubPlanState *ExecInitSubPlan(SubPlan *subplan, PlanState *parent);
+
+extern Datum ExecSubPlan(SubPlanState *node, ExprContext *econtext, bool *isNull);
+
+extern void ExecReScanSetParamPlan(SubPlanState *node, PlanState *parent);
+
+extern void ExecSetParamPlan(SubPlanState *node, ExprContext *econtext);
+
+extern void ExecSetParamPlanMulti(const Bitmapset *params, ExprContext *econtext);
+
+#endif							/* NODESUBPLAN_H */

embedded_postgres/pginstall/include/server/executor/nodeSubqueryscan.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeSubqueryscan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeSubqueryscan.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODESUBQUERYSCAN_H
+#define NODESUBQUERYSCAN_H
+
+#include "nodes/execnodes.h"
+
+extern SubqueryScanState *ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags);
+extern void ExecEndSubqueryScan(SubqueryScanState *node);
+extern void ExecReScanSubqueryScan(SubqueryScanState *node);
+
+#endif							/* NODESUBQUERYSCAN_H */

embedded_postgres/pginstall/include/server/executor/nodeTableFuncscan.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeTableFuncscan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeTableFuncscan.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODETABLEFUNCSCAN_H
+#define NODETABLEFUNCSCAN_H
+
+#include "nodes/execnodes.h"
+
+extern TableFuncScanState *ExecInitTableFuncScan(TableFuncScan *node, EState *estate, int eflags);
+extern void ExecEndTableFuncScan(TableFuncScanState *node);
+extern void ExecReScanTableFuncScan(TableFuncScanState *node);
+
+#endif							/* NODETABLEFUNCSCAN_H */

embedded_postgres/pginstall/include/server/executor/nodeTidrangescan.h

@@ -0,0 +1,24 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeTidrangescan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeTidrangescan.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODETIDRANGESCAN_H
+#define NODETIDRANGESCAN_H
+
+#include "nodes/execnodes.h"
+
+extern TidRangeScanState *ExecInitTidRangeScan(TidRangeScan *node,
+											   EState *estate, int eflags);
+extern void ExecEndTidRangeScan(TidRangeScanState *node);
+extern void ExecReScanTidRangeScan(TidRangeScanState *node);
+
+#endif							/* NODETIDRANGESCAN_H */

embedded_postgres/pginstall/include/server/executor/nodeTidscan.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeTidscan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeTidscan.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODETIDSCAN_H
+#define NODETIDSCAN_H
+
+#include "nodes/execnodes.h"
+
+extern TidScanState *ExecInitTidScan(TidScan *node, EState *estate, int eflags);
+extern void ExecEndTidScan(TidScanState *node);
+extern void ExecReScanTidScan(TidScanState *node);
+
+#endif							/* NODETIDSCAN_H */

embedded_postgres/pginstall/include/server/executor/nodeUnique.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeUnique.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeUnique.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODEUNIQUE_H
+#define NODEUNIQUE_H
+
+#include "nodes/execnodes.h"
+
+extern UniqueState *ExecInitUnique(Unique *node, EState *estate, int eflags);
+extern void ExecEndUnique(UniqueState *node);
+extern void ExecReScanUnique(UniqueState *node);
+
+#endif							/* NODEUNIQUE_H */

embedded_postgres/pginstall/include/server/executor/nodeValuesscan.h

@@ -0,0 +1,22 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeValuesscan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeValuesscan.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODEVALUESSCAN_H
+#define NODEVALUESSCAN_H
+
+#include "nodes/execnodes.h"
+
+extern ValuesScanState *ExecInitValuesScan(ValuesScan *node, EState *estate, int eflags);
+extern void ExecReScanValuesScan(ValuesScanState *node);
+
+#endif							/* NODEVALUESSCAN_H */

embedded_postgres/pginstall/include/server/executor/nodeWindowAgg.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeWindowAgg.h
+ *	  prototypes for nodeWindowAgg.c
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeWindowAgg.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODEWINDOWAGG_H
+#define NODEWINDOWAGG_H
+
+#include "nodes/execnodes.h"
+
+extern WindowAggState *ExecInitWindowAgg(WindowAgg *node, EState *estate, int eflags);
+extern void ExecEndWindowAgg(WindowAggState *node);
+extern void ExecReScanWindowAgg(WindowAggState *node);
+
+#endif							/* NODEWINDOWAGG_H */

embedded_postgres/pginstall/include/server/executor/nodeWorktablescan.h

@@ -0,0 +1,22 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeWorktablescan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeWorktablescan.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODEWORKTABLESCAN_H
+#define NODEWORKTABLESCAN_H
+
+#include "nodes/execnodes.h"
+
+extern WorkTableScanState *ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags);
+extern void ExecReScanWorkTableScan(WorkTableScanState *node);
+
+#endif							/* NODEWORKTABLESCAN_H */

embedded_postgres/pginstall/include/server/executor/spi.h

@@ -0,0 +1,207 @@
+/*-------------------------------------------------------------------------
+ *
+ * spi.h
+ *				Server Programming Interface public declarations
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/spi.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SPI_H
+#define SPI_H
+
+#include "commands/trigger.h"
+#include "lib/ilist.h"
+#include "parser/parser.h"
+#include "utils/portal.h"
+
+
+typedef struct SPITupleTable
+{
+	/* Public members */
+	TupleDesc	tupdesc;		/* tuple descriptor */
+	HeapTuple  *vals;			/* array of tuples */
+	uint64		numvals;		/* number of valid tuples */
+
+	/* Private members, not intended for external callers */
+	uint64		alloced;		/* allocated length of vals array */
+	MemoryContext tuptabcxt;	/* memory context of result table */
+	slist_node	next;			/* link for internal bookkeeping */
+	SubTransactionId subid;		/* subxact in which tuptable was created */
+} SPITupleTable;
+
+/* Optional arguments for SPI_prepare_extended */
+typedef struct SPIPrepareOptions
+{
+	ParserSetupHook parserSetup;
+	void	   *parserSetupArg;
+	RawParseMode parseMode;
+	int			cursorOptions;
+} SPIPrepareOptions;
+
+/* Optional arguments for SPI_execute[_plan]_extended */
+typedef struct SPIExecuteOptions
+{
+	ParamListInfo params;
+	bool		read_only;
+	bool		allow_nonatomic;
+	bool		must_return_tuples;
+	uint64		tcount;
+	DestReceiver *dest;
+	ResourceOwner owner;
+} SPIExecuteOptions;
+
+/* Optional arguments for SPI_cursor_parse_open */
+typedef struct SPIParseOpenOptions
+{
+	ParamListInfo params;
+	int			cursorOptions;
+	bool		read_only;
+} SPIParseOpenOptions;
+
+/* Plans are opaque structs for standard users of SPI */
+typedef struct _SPI_plan *SPIPlanPtr;
+
+#define SPI_ERROR_CONNECT		(-1)
+#define SPI_ERROR_COPY			(-2)
+#define SPI_ERROR_OPUNKNOWN		(-3)
+#define SPI_ERROR_UNCONNECTED	(-4)
+#define SPI_ERROR_CURSOR		(-5)	/* not used anymore */
+#define SPI_ERROR_ARGUMENT		(-6)
+#define SPI_ERROR_PARAM			(-7)
+#define SPI_ERROR_TRANSACTION	(-8)
+#define SPI_ERROR_NOATTRIBUTE	(-9)
+#define SPI_ERROR_NOOUTFUNC		(-10)
+#define SPI_ERROR_TYPUNKNOWN	(-11)
+#define SPI_ERROR_REL_DUPLICATE (-12)
+#define SPI_ERROR_REL_NOT_FOUND (-13)
+
+#define SPI_OK_CONNECT			1
+#define SPI_OK_FINISH			2
+#define SPI_OK_FETCH			3
+#define SPI_OK_UTILITY			4
+#define SPI_OK_SELECT			5
+#define SPI_OK_SELINTO			6
+#define SPI_OK_INSERT			7
+#define SPI_OK_DELETE			8
+#define SPI_OK_UPDATE			9
+#define SPI_OK_CURSOR			10
+#define SPI_OK_INSERT_RETURNING 11
+#define SPI_OK_DELETE_RETURNING 12
+#define SPI_OK_UPDATE_RETURNING 13
+#define SPI_OK_REWRITTEN		14
+#define SPI_OK_REL_REGISTER		15
+#define SPI_OK_REL_UNREGISTER	16
+#define SPI_OK_TD_REGISTER		17
+#define SPI_OK_MERGE			18
+#define SPI_OK_MERGE_RETURNING	19
+
+#define SPI_OPT_NONATOMIC		(1 << 0)
+
+extern PGDLLIMPORT uint64 SPI_processed;
+extern PGDLLIMPORT SPITupleTable *SPI_tuptable;
+extern PGDLLIMPORT int SPI_result;
+
+extern int	SPI_connect(void);
+extern int	SPI_connect_ext(int options);
+extern int	SPI_finish(void);
+extern int	SPI_execute(const char *src, bool read_only, long tcount);
+extern int	SPI_execute_extended(const char *src,
+								 const SPIExecuteOptions *options);
+extern int	SPI_execute_plan(SPIPlanPtr plan, Datum *Values, const char *Nulls,
+							 bool read_only, long tcount);
+extern int	SPI_execute_plan_extended(SPIPlanPtr plan,
+									  const SPIExecuteOptions *options);
+extern int	SPI_execute_plan_with_paramlist(SPIPlanPtr plan,
+											ParamListInfo params,
+											bool read_only, long tcount);
+extern int	SPI_exec(const char *src, long tcount);
+extern int	SPI_execp(SPIPlanPtr plan, Datum *Values, const char *Nulls,
+					  long tcount);
+extern int	SPI_execute_snapshot(SPIPlanPtr plan,
+								 Datum *Values, const char *Nulls,
+								 Snapshot snapshot,
+								 Snapshot crosscheck_snapshot,
+								 bool read_only, bool fire_triggers, long tcount);
+extern int	SPI_execute_with_args(const char *src,
+								  int nargs, Oid *argtypes,
+								  Datum *Values, const char *Nulls,
+								  bool read_only, long tcount);
+extern SPIPlanPtr SPI_prepare(const char *src, int nargs, Oid *argtypes);
+extern SPIPlanPtr SPI_prepare_cursor(const char *src, int nargs, Oid *argtypes,
+									 int cursorOptions);
+extern SPIPlanPtr SPI_prepare_extended(const char *src,
+									   const SPIPrepareOptions *options);
+extern SPIPlanPtr SPI_prepare_params(const char *src,
+									 ParserSetupHook parserSetup,
+									 void *parserSetupArg,
+									 int cursorOptions);
+extern int	SPI_keepplan(SPIPlanPtr plan);
+extern SPIPlanPtr SPI_saveplan(SPIPlanPtr plan);
+extern int	SPI_freeplan(SPIPlanPtr plan);
+
+extern Oid	SPI_getargtypeid(SPIPlanPtr plan, int argIndex);
+extern int	SPI_getargcount(SPIPlanPtr plan);
+extern bool SPI_is_cursor_plan(SPIPlanPtr plan);
+extern bool SPI_plan_is_valid(SPIPlanPtr plan);
+extern const char *SPI_result_code_string(int code);
+
+extern List *SPI_plan_get_plan_sources(SPIPlanPtr plan);
+extern CachedPlan *SPI_plan_get_cached_plan(SPIPlanPtr plan);
+
+extern HeapTuple SPI_copytuple(HeapTuple tuple);
+extern HeapTupleHeader SPI_returntuple(HeapTuple tuple, TupleDesc tupdesc);
+extern HeapTuple SPI_modifytuple(Relation rel, HeapTuple tuple, int natts,
+								 int *attnum, Datum *Values, const char *Nulls);
+extern int	SPI_fnumber(TupleDesc tupdesc, const char *fname);
+extern char *SPI_fname(TupleDesc tupdesc, int fnumber);
+extern char *SPI_getvalue(HeapTuple tuple, TupleDesc tupdesc, int fnumber);
+extern Datum SPI_getbinval(HeapTuple tuple, TupleDesc tupdesc, int fnumber, bool *isnull);
+extern char *SPI_gettype(TupleDesc tupdesc, int fnumber);
+extern Oid	SPI_gettypeid(TupleDesc tupdesc, int fnumber);
+extern char *SPI_getrelname(Relation rel);
+extern char *SPI_getnspname(Relation rel);
+extern void *SPI_palloc(Size size);
+extern void *SPI_repalloc(void *pointer, Size size);
+extern void SPI_pfree(void *pointer);
+extern Datum SPI_datumTransfer(Datum value, bool typByVal, int typLen);
+extern void SPI_freetuple(HeapTuple tuple);
+extern void SPI_freetuptable(SPITupleTable *tuptable);
+
+extern Portal SPI_cursor_open(const char *name, SPIPlanPtr plan,
+							  Datum *Values, const char *Nulls, bool read_only);
+extern Portal SPI_cursor_open_with_args(const char *name,
+										const char *src,
+										int nargs, Oid *argtypes,
+										Datum *Values, const char *Nulls,
+										bool read_only, int cursorOptions);
+extern Portal SPI_cursor_open_with_paramlist(const char *name, SPIPlanPtr plan,
+											 ParamListInfo params, bool read_only);
+extern Portal SPI_cursor_parse_open(const char *name,
+									const char *src,
+									const SPIParseOpenOptions *options);
+extern Portal SPI_cursor_find(const char *name);
+extern void SPI_cursor_fetch(Portal portal, bool forward, long count);
+extern void SPI_cursor_move(Portal portal, bool forward, long count);
+extern void SPI_scroll_cursor_fetch(Portal, FetchDirection direction, long count);
+extern void SPI_scroll_cursor_move(Portal, FetchDirection direction, long count);
+extern void SPI_cursor_close(Portal portal);
+
+extern int	SPI_register_relation(EphemeralNamedRelation enr);
+extern int	SPI_unregister_relation(const char *name);
+extern int	SPI_register_trigger_data(TriggerData *tdata);
+
+extern void SPI_start_transaction(void);
+extern void SPI_commit(void);
+extern void SPI_commit_and_chain(void);
+extern void SPI_rollback(void);
+extern void SPI_rollback_and_chain(void);
+
+extern void AtEOXact_SPI(bool isCommit);
+extern void AtEOSubXact_SPI(bool isCommit, SubTransactionId mySubid);
+extern bool SPI_inside_nonatomic_context(void);
+
+#endif							/* SPI_H */

embedded_postgres/pginstall/include/server/executor/spi_priv.h

@@ -0,0 +1,105 @@
+/*-------------------------------------------------------------------------
+ *
+ * spi_priv.h
+ *				Server Programming Interface private declarations
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/spi_priv.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef SPI_PRIV_H
+#define SPI_PRIV_H
+
+#include "executor/spi.h"
+#include "utils/queryenvironment.h"
+
+
+#define _SPI_PLAN_MAGIC		569278163
+
+typedef struct
+{
+	/* current results */
+	uint64		processed;		/* by Executor */
+	SPITupleTable *tuptable;	/* tuptable currently being built */
+
+	/* subtransaction in which current Executor call was started */
+	SubTransactionId execSubid;
+
+	/* resources of this execution context */
+	slist_head	tuptables;		/* list of all live SPITupleTables */
+	MemoryContext procCxt;		/* procedure context */
+	MemoryContext execCxt;		/* executor context */
+	MemoryContext savedcxt;		/* context of SPI_connect's caller */
+	SubTransactionId connectSubid;	/* ID of connecting subtransaction */
+	QueryEnvironment *queryEnv; /* query environment setup for SPI level */
+
+	/* transaction management support */
+	bool		atomic;			/* atomic execution context, does not allow
+								 * transactions */
+	bool		internal_xact;	/* SPI-managed transaction boundary, skip
+								 * cleanup */
+
+	/* saved values of API global variables for previous nesting level */
+	uint64		outer_processed;
+	SPITupleTable *outer_tuptable;
+	int			outer_result;
+} _SPI_connection;
+
+/*
+ * SPI plans have three states: saved, unsaved, or temporary.
+ *
+ * Ordinarily, the _SPI_plan struct itself as well as the argtypes array
+ * are in a dedicated memory context identified by plancxt (which can be
+ * really small).  All the other subsidiary state is in plancache entries
+ * identified by plancache_list (note: the list cells themselves are in
+ * plancxt).
+ *
+ * In an unsaved plan, the plancxt as well as the plancache entries' contexts
+ * are children of the SPI procedure context, so they'll all disappear at
+ * function exit.  plancache.c also knows that the plancache entries are
+ * "unsaved", so it doesn't link them into its global list; hence they do
+ * not respond to inval events.  This is OK since we are presumably holding
+ * adequate locks to prevent other backends from messing with the tables.
+ *
+ * For a saved plan, the plancxt is made a child of CacheMemoryContext
+ * since it should persist until explicitly destroyed.  Likewise, the
+ * plancache entries will be under CacheMemoryContext since we tell
+ * plancache.c to save them.  We rely on plancache.c to keep the cache
+ * entries up-to-date as needed in the face of invalidation events.
+ *
+ * There are also "temporary" SPI plans, in which the _SPI_plan struct is
+ * not even palloc'd but just exists in some function's local variable.
+ * The plancache entries are unsaved and exist under the SPI executor context,
+ * while additional data such as argtypes and list cells is loose in the SPI
+ * executor context.  Such plans can be identified by having plancxt == NULL.
+ *
+ * We can also have "one-shot" SPI plans (which are typically temporary,
+ * as described above).  These are meant to be executed once and discarded,
+ * and various optimizations are made on the assumption of single use.
+ * Note in particular that the CachedPlanSources within such an SPI plan
+ * are not "complete" until execution.
+ *
+ * Note: if the original query string contained only whitespace and comments,
+ * the plancache_list will be NIL and so there is no place to store the
+ * query string.  We don't care about that, but we do care about the
+ * argument type array, which is why it's seemingly-redundantly stored.
+ */
+typedef struct _SPI_plan
+{
+	int			magic;			/* should equal _SPI_PLAN_MAGIC */
+	bool		saved;			/* saved or unsaved plan? */
+	bool		oneshot;		/* one-shot plan? */
+	List	   *plancache_list; /* one CachedPlanSource per parsetree */
+	MemoryContext plancxt;		/* Context containing _SPI_plan and data */
+	RawParseMode parse_mode;	/* raw_parser() mode */
+	int			cursor_options; /* Cursor options used for planning */
+	int			nargs;			/* number of plan arguments */
+	Oid		   *argtypes;		/* Argument types (NULL if nargs is 0) */
+	ParserSetupHook parserSetup;	/* alternative parameter spec method */
+	void	   *parserSetupArg;
+} _SPI_plan;
+
+#endif							/* SPI_PRIV_H */

embedded_postgres/pginstall/include/server/executor/tablefunc.h

@@ -0,0 +1,67 @@
+/*-------------------------------------------------------------------------
+ *
+ * tablefunc.h
+ *				interface for TableFunc executor node
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/tablefunc.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef _TABLEFUNC_H
+#define _TABLEFUNC_H
+
+/* Forward-declare this to avoid including execnodes.h here */
+struct TableFuncScanState;
+
+/*
+ * TableFuncRoutine holds function pointers used for generating content of
+ * table-producer functions, such as XMLTABLE.
+ *
+ * InitOpaque initializes table builder private objects.  The output tuple
+ * descriptor, input functions for the columns, and typioparams are passed
+ * from executor state.
+ *
+ * SetDocument is called to define the input document.  The table builder may
+ * apply additional transformations not exposed outside the table builder
+ * context.
+ *
+ * SetNamespace is called to pass namespace declarations from the table
+ * expression.  This function may be NULL if namespaces are not supported by
+ * the table builder.  Namespaces must be given before setting the row and
+ * column filters.  If the name is given as NULL, the entry shall be for the
+ * default namespace.
+ *
+ * SetRowFilter is called do define the row-generating filter, which shall be
+ * used to extract each row from the input document.
+ *
+ * SetColumnFilter is called once for each column, to define the column-
+ * generating filter for the given column.
+ *
+ * FetchRow shall be called repeatedly until it returns that no more rows are
+ * found in the document.  On each invocation it shall set state in the table
+ * builder context such that each subsequent GetValue call returns the values
+ * for the indicated column for the row being processed.
+ *
+ * DestroyOpaque shall release all resources associated with a table builder
+ * context.  It may be called either because all rows have been consumed, or
+ * because an error occurred while processing the table expression.
+ */
+typedef struct TableFuncRoutine
+{
+	void		(*InitOpaque) (struct TableFuncScanState *state, int natts);
+	void		(*SetDocument) (struct TableFuncScanState *state, Datum value);
+	void		(*SetNamespace) (struct TableFuncScanState *state, const char *name,
+								 const char *uri);
+	void		(*SetRowFilter) (struct TableFuncScanState *state, const char *path);
+	void		(*SetColumnFilter) (struct TableFuncScanState *state,
+									const char *path, int colnum);
+	bool		(*FetchRow) (struct TableFuncScanState *state);
+	Datum		(*GetValue) (struct TableFuncScanState *state, int colnum,
+							 Oid typid, int32 typmod, bool *isnull);
+	void		(*DestroyOpaque) (struct TableFuncScanState *state);
+} TableFuncRoutine;
+
+#endif							/* _TABLEFUNC_H */

embedded_postgres/pginstall/include/server/executor/tqueue.h

@@ -0,0 +1,32 @@
+/*-------------------------------------------------------------------------
+ *
+ * tqueue.h
+ *	  Use shm_mq to send & receive tuples between parallel backends
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/tqueue.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef TQUEUE_H
+#define TQUEUE_H
+
+#include "storage/shm_mq.h"
+#include "tcop/dest.h"
+
+/* Opaque struct, only known inside tqueue.c. */
+typedef struct TupleQueueReader TupleQueueReader;
+
+/* Use this to send tuples to a shm_mq. */
+extern DestReceiver *CreateTupleQueueDestReceiver(shm_mq_handle *handle);
+
+/* Use these to receive tuples from a shm_mq. */
+extern TupleQueueReader *CreateTupleQueueReader(shm_mq_handle *handle);
+extern void DestroyTupleQueueReader(TupleQueueReader *reader);
+extern MinimalTuple TupleQueueReaderNext(TupleQueueReader *reader,
+										 bool nowait, bool *done);
+
+#endif							/* TQUEUE_H */