pg_query 5.0.0 → 6.0.0

data/ext/pg_query/include/foreign/fdwapi.h

@@ -1,294 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * fdwapi.h
- *	  API for foreign-data wrappers
- *
- * Copyright (c) 2010-2023, PostgreSQL Global Development Group
- *
- * src/include/foreign/fdwapi.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef FDWAPI_H
-#define FDWAPI_H
-
-#include "access/parallel.h"
-#include "nodes/execnodes.h"
-#include "nodes/pathnodes.h"
-
-/* To avoid including explain.h here, reference ExplainState thus: */
-struct ExplainState;
-
-
-/*
- * Callback function signatures --- see fdwhandler.sgml for more info.
- */
-
-typedef void (*GetForeignRelSize_function) (PlannerInfo *root,
-											RelOptInfo *baserel,
-											Oid foreigntableid);
-
-typedef void (*GetForeignPaths_function) (PlannerInfo *root,
-										  RelOptInfo *baserel,
-										  Oid foreigntableid);
-
-typedef ForeignScan *(*GetForeignPlan_function) (PlannerInfo *root,
-												 RelOptInfo *baserel,
-												 Oid foreigntableid,
-												 ForeignPath *best_path,
-												 List *tlist,
-												 List *scan_clauses,
-												 Plan *outer_plan);
-
-typedef void (*BeginForeignScan_function) (ForeignScanState *node,
-										   int eflags);
-
-typedef TupleTableSlot *(*IterateForeignScan_function) (ForeignScanState *node);
-
-typedef bool (*RecheckForeignScan_function) (ForeignScanState *node,
-											 TupleTableSlot *slot);
-
-typedef void (*ReScanForeignScan_function) (ForeignScanState *node);
-
-typedef void (*EndForeignScan_function) (ForeignScanState *node);
-
-typedef void (*GetForeignJoinPaths_function) (PlannerInfo *root,
-											  RelOptInfo *joinrel,
-											  RelOptInfo *outerrel,
-											  RelOptInfo *innerrel,
-											  JoinType jointype,
-											  JoinPathExtraData *extra);
-
-typedef void (*GetForeignUpperPaths_function) (PlannerInfo *root,
-											   UpperRelationKind stage,
-											   RelOptInfo *input_rel,
-											   RelOptInfo *output_rel,
-											   void *extra);
-
-typedef void (*AddForeignUpdateTargets_function) (PlannerInfo *root,
-												  Index rtindex,
-												  RangeTblEntry *target_rte,
-												  Relation target_relation);
-
-typedef List *(*PlanForeignModify_function) (PlannerInfo *root,
-											 ModifyTable *plan,
-											 Index resultRelation,
-											 int subplan_index);
-
-typedef void (*BeginForeignModify_function) (ModifyTableState *mtstate,
-											 ResultRelInfo *rinfo,
-											 List *fdw_private,
-											 int subplan_index,
-											 int eflags);
-
-typedef TupleTableSlot *(*ExecForeignInsert_function) (EState *estate,
-													   ResultRelInfo *rinfo,
-													   TupleTableSlot *slot,
-													   TupleTableSlot *planSlot);
-
-typedef TupleTableSlot **(*ExecForeignBatchInsert_function) (EState *estate,
-															 ResultRelInfo *rinfo,
-															 TupleTableSlot **slots,
-															 TupleTableSlot **planSlots,
-															 int *numSlots);
-
-typedef int (*GetForeignModifyBatchSize_function) (ResultRelInfo *rinfo);
-
-typedef TupleTableSlot *(*ExecForeignUpdate_function) (EState *estate,
-													   ResultRelInfo *rinfo,
-													   TupleTableSlot *slot,
-													   TupleTableSlot *planSlot);
-
-typedef TupleTableSlot *(*ExecForeignDelete_function) (EState *estate,
-													   ResultRelInfo *rinfo,
-													   TupleTableSlot *slot,
-													   TupleTableSlot *planSlot);
-
-typedef void (*EndForeignModify_function) (EState *estate,
-										   ResultRelInfo *rinfo);
-
-typedef void (*BeginForeignInsert_function) (ModifyTableState *mtstate,
-											 ResultRelInfo *rinfo);
-
-typedef void (*EndForeignInsert_function) (EState *estate,
-										   ResultRelInfo *rinfo);
-
-typedef int (*IsForeignRelUpdatable_function) (Relation rel);
-
-typedef bool (*PlanDirectModify_function) (PlannerInfo *root,
-										   ModifyTable *plan,
-										   Index resultRelation,
-										   int subplan_index);
-
-typedef void (*BeginDirectModify_function) (ForeignScanState *node,
-											int eflags);
-
-typedef TupleTableSlot *(*IterateDirectModify_function) (ForeignScanState *node);
-
-typedef void (*EndDirectModify_function) (ForeignScanState *node);
-
-typedef RowMarkType (*GetForeignRowMarkType_function) (RangeTblEntry *rte,
-													   LockClauseStrength strength);
-
-typedef void (*RefetchForeignRow_function) (EState *estate,
-											ExecRowMark *erm,
-											Datum rowid,
-											TupleTableSlot *slot,
-											bool *updated);
-
-typedef void (*ExplainForeignScan_function) (ForeignScanState *node,
-											 struct ExplainState *es);
-
-typedef void (*ExplainForeignModify_function) (ModifyTableState *mtstate,
-											   ResultRelInfo *rinfo,
-											   List *fdw_private,
-											   int subplan_index,
-											   struct ExplainState *es);
-
-typedef void (*ExplainDirectModify_function) (ForeignScanState *node,
-											  struct ExplainState *es);
-
-typedef int (*AcquireSampleRowsFunc) (Relation relation, int elevel,
-									  HeapTuple *rows, int targrows,
-									  double *totalrows,
-									  double *totaldeadrows);
-
-typedef bool (*AnalyzeForeignTable_function) (Relation relation,
-											  AcquireSampleRowsFunc *func,
-											  BlockNumber *totalpages);
-
-typedef List *(*ImportForeignSchema_function) (ImportForeignSchemaStmt *stmt,
-											   Oid serverOid);
-
-typedef void (*ExecForeignTruncate_function) (List *rels,
-											  DropBehavior behavior,
-											  bool restart_seqs);
-
-typedef Size (*EstimateDSMForeignScan_function) (ForeignScanState *node,
-												 ParallelContext *pcxt);
-typedef void (*InitializeDSMForeignScan_function) (ForeignScanState *node,
-												   ParallelContext *pcxt,
-												   void *coordinate);
-typedef void (*ReInitializeDSMForeignScan_function) (ForeignScanState *node,
-													 ParallelContext *pcxt,
-													 void *coordinate);
-typedef void (*InitializeWorkerForeignScan_function) (ForeignScanState *node,
-													  shm_toc *toc,
-													  void *coordinate);
-typedef void (*ShutdownForeignScan_function) (ForeignScanState *node);
-typedef bool (*IsForeignScanParallelSafe_function) (PlannerInfo *root,
-													RelOptInfo *rel,
-													RangeTblEntry *rte);
-typedef List *(*ReparameterizeForeignPathByChild_function) (PlannerInfo *root,
-															List *fdw_private,
-															RelOptInfo *child_rel);
-
-typedef bool (*IsForeignPathAsyncCapable_function) (ForeignPath *path);
-
-typedef void (*ForeignAsyncRequest_function) (AsyncRequest *areq);
-
-typedef void (*ForeignAsyncConfigureWait_function) (AsyncRequest *areq);
-
-typedef void (*ForeignAsyncNotify_function) (AsyncRequest *areq);
-
-/*
- * FdwRoutine is the struct returned by a foreign-data wrapper's handler
- * function.  It provides pointers to the callback functions needed by the
- * planner and executor.
- *
- * More function pointers are likely to be added in the future.  Therefore
- * it's recommended that the handler initialize the struct with
- * makeNode(FdwRoutine) so that all fields are set to NULL.  This will
- * ensure that no fields are accidentally left undefined.
- */
-typedef struct FdwRoutine
-{
-	NodeTag		type;
-
-	/* Functions for scanning foreign tables */
-	GetForeignRelSize_function GetForeignRelSize;
-	GetForeignPaths_function GetForeignPaths;
-	GetForeignPlan_function GetForeignPlan;
-	BeginForeignScan_function BeginForeignScan;
-	IterateForeignScan_function IterateForeignScan;
-	ReScanForeignScan_function ReScanForeignScan;
-	EndForeignScan_function EndForeignScan;
-
-	/*
-	 * Remaining functions are optional.  Set the pointer to NULL for any that
-	 * are not provided.
-	 */
-
-	/* Functions for remote-join planning */
-	GetForeignJoinPaths_function GetForeignJoinPaths;
-
-	/* Functions for remote upper-relation (post scan/join) planning */
-	GetForeignUpperPaths_function GetForeignUpperPaths;
-
-	/* Functions for updating foreign tables */
-	AddForeignUpdateTargets_function AddForeignUpdateTargets;
-	PlanForeignModify_function PlanForeignModify;
-	BeginForeignModify_function BeginForeignModify;
-	ExecForeignInsert_function ExecForeignInsert;
-	ExecForeignBatchInsert_function ExecForeignBatchInsert;
-	GetForeignModifyBatchSize_function GetForeignModifyBatchSize;
-	ExecForeignUpdate_function ExecForeignUpdate;
-	ExecForeignDelete_function ExecForeignDelete;
-	EndForeignModify_function EndForeignModify;
-	BeginForeignInsert_function BeginForeignInsert;
-	EndForeignInsert_function EndForeignInsert;
-	IsForeignRelUpdatable_function IsForeignRelUpdatable;
-	PlanDirectModify_function PlanDirectModify;
-	BeginDirectModify_function BeginDirectModify;
-	IterateDirectModify_function IterateDirectModify;
-	EndDirectModify_function EndDirectModify;
-
-	/* Functions for SELECT FOR UPDATE/SHARE row locking */
-	GetForeignRowMarkType_function GetForeignRowMarkType;
-	RefetchForeignRow_function RefetchForeignRow;
-	RecheckForeignScan_function RecheckForeignScan;
-
-	/* Support functions for EXPLAIN */
-	ExplainForeignScan_function ExplainForeignScan;
-	ExplainForeignModify_function ExplainForeignModify;
-	ExplainDirectModify_function ExplainDirectModify;
-
-	/* Support functions for ANALYZE */
-	AnalyzeForeignTable_function AnalyzeForeignTable;
-
-	/* Support functions for IMPORT FOREIGN SCHEMA */
-	ImportForeignSchema_function ImportForeignSchema;
-
-	/* Support functions for TRUNCATE */
-	ExecForeignTruncate_function ExecForeignTruncate;
-
-	/* Support functions for parallelism under Gather node */
-	IsForeignScanParallelSafe_function IsForeignScanParallelSafe;
-	EstimateDSMForeignScan_function EstimateDSMForeignScan;
-	InitializeDSMForeignScan_function InitializeDSMForeignScan;
-	ReInitializeDSMForeignScan_function ReInitializeDSMForeignScan;
-	InitializeWorkerForeignScan_function InitializeWorkerForeignScan;
-	ShutdownForeignScan_function ShutdownForeignScan;
-
-	/* Support functions for path reparameterization. */
-	ReparameterizeForeignPathByChild_function ReparameterizeForeignPathByChild;
-
-	/* Support functions for asynchronous execution */
-	IsForeignPathAsyncCapable_function IsForeignPathAsyncCapable;
-	ForeignAsyncRequest_function ForeignAsyncRequest;
-	ForeignAsyncConfigureWait_function ForeignAsyncConfigureWait;
-	ForeignAsyncNotify_function ForeignAsyncNotify;
-} FdwRoutine;
-
-
-/* Functions in foreign/foreign.c */
-extern FdwRoutine *GetFdwRoutine(Oid fdwhandler);
-extern Oid	GetForeignServerIdByRelId(Oid relid);
-extern FdwRoutine *GetFdwRoutineByServerId(Oid serverid);
-extern FdwRoutine *GetFdwRoutineByRelId(Oid relid);
-extern FdwRoutine *GetFdwRoutineForRelation(Relation relation, bool makecopy);
-extern bool IsImportableForeignTable(const char *tablename,
-									 ImportForeignSchemaStmt *stmt);
-extern Path *GetExistingLocalJoinPath(RelOptInfo *joinrel);
-
-#endif							/* FDWAPI_H */

data/ext/pg_query/include/funcapi.h

@@ -1,360 +0,0 @@
-/*-------------------------------------------------------------------------
- *
- * funcapi.h
- *	  Definitions for functions which return composite type and/or sets
- *	  or work on VARIADIC inputs.
- *
- * This file must be included by all Postgres modules that either define
- * or call FUNCAPI-callable functions or macros.
- *
- *
- * Copyright (c) 2002-2023, PostgreSQL Global Development Group
- *
- * src/include/funcapi.h
- *
- *-------------------------------------------------------------------------
- */
-#ifndef FUNCAPI_H
-#define FUNCAPI_H
-
-#include "access/tupdesc.h"
-#include "executor/executor.h"
-#include "executor/tuptable.h"
-#include "fmgr.h"
-
-/*-------------------------------------------------------------------------
- *	Support to ease writing Functions returning composite types
- *-------------------------------------------------------------------------
- *
- * This struct holds arrays of individual attribute information
- * needed to create a tuple from raw C strings. It also requires
- * a copy of the TupleDesc. The information carried here
- * is derived from the TupleDesc, but it is stored here to
- * avoid redundant cpu cycles on each call to an SRF.
- */
-typedef struct AttInMetadata
-{
-	/* full TupleDesc */
-	TupleDesc	tupdesc;
-
-	/* array of attribute type input function finfo */
-	FmgrInfo   *attinfuncs;
-
-	/* array of attribute type i/o parameter OIDs */
-	Oid		   *attioparams;
-
-	/* array of attribute typmod */
-	int32	   *atttypmods;
-} AttInMetadata;
-
-/*-------------------------------------------------------------------------
- *		Support struct to ease writing Set Returning Functions (SRFs)
- *-------------------------------------------------------------------------
- *
- * This struct holds function context for Set Returning Functions.
- * Use fn_extra to hold a pointer to it across calls
- */
-typedef struct FuncCallContext
-{
-	/*
-	 * Number of times we've been called before
-	 *
-	 * call_cntr is initialized to 0 for you by SRF_FIRSTCALL_INIT(), and
-	 * incremented for you every time SRF_RETURN_NEXT() is called.
-	 */
-	uint64		call_cntr;
-
-	/*
-	 * OPTIONAL maximum number of calls
-	 *
-	 * max_calls is here for convenience only and setting it is optional. If
-	 * not set, you must provide alternative means to know when the function
-	 * is done.
-	 */
-	uint64		max_calls;
-
-	/*
-	 * OPTIONAL pointer to miscellaneous user-provided context information
-	 *
-	 * user_fctx is for use as a pointer to your own struct to retain
-	 * arbitrary context information between calls of your function.
-	 */
-	void	   *user_fctx;
-
-	/*
-	 * OPTIONAL pointer to struct containing attribute type input metadata
-	 *
-	 * attinmeta is for use when returning tuples (i.e. composite data types)
-	 * and is not used when returning base data types. It is only needed if
-	 * you intend to use BuildTupleFromCStrings() to create the return tuple.
-	 */
-	AttInMetadata *attinmeta;
-
-	/*
-	 * memory context used for structures that must live for multiple calls
-	 *
-	 * multi_call_memory_ctx is set by SRF_FIRSTCALL_INIT() for you, and used
-	 * by SRF_RETURN_DONE() for cleanup. It is the most appropriate memory
-	 * context for any memory that is to be reused across multiple calls of
-	 * the SRF.
-	 */
-	MemoryContext multi_call_memory_ctx;
-
-	/*
-	 * OPTIONAL pointer to struct containing tuple description
-	 *
-	 * tuple_desc is for use when returning tuples (i.e. composite data types)
-	 * and is only needed if you are going to build the tuples with
-	 * heap_form_tuple() rather than with BuildTupleFromCStrings(). Note that
-	 * the TupleDesc pointer stored here should usually have been run through
-	 * BlessTupleDesc() first.
-	 */
-	TupleDesc	tuple_desc;
-
-} FuncCallContext;
-
-/*----------
- *	Support to ease writing functions returning composite types
- *
- * External declarations:
- * get_call_result_type:
- *		Given a function's call info record, determine the kind of datatype
- *		it is supposed to return.  If resultTypeId isn't NULL, *resultTypeId
- *		receives the actual datatype OID (this is mainly useful for scalar
- *		result types).  If resultTupleDesc isn't NULL, *resultTupleDesc
- *		receives a pointer to a TupleDesc when the result is of a composite
- *		type, or NULL when it's a scalar result or the rowtype could not be
- *		determined.  NB: the tupledesc should be copied if it is to be
- *		accessed over a long period.
- * get_expr_result_type:
- *		Given an expression node, return the same info as for
- *		get_call_result_type.  Note: the cases in which rowtypes cannot be
- *		determined are different from the cases for get_call_result_type.
- * get_func_result_type:
- *		Given only a function's OID, return the same info as for
- *		get_call_result_type.  Note: the cases in which rowtypes cannot be
- *		determined are different from the cases for get_call_result_type.
- *		Do *not* use this if you can use one of the others.
- *
- * See also get_expr_result_tupdesc(), which is a convenient wrapper around
- * get_expr_result_type() for use when the caller only cares about
- * determinable-rowtype cases.
- *----------
- */
-
-/* Type categories for get_call_result_type and siblings */
-typedef enum TypeFuncClass
-{
-	TYPEFUNC_SCALAR,			/* scalar result type */
-	TYPEFUNC_COMPOSITE,			/* determinable rowtype result */
-	TYPEFUNC_COMPOSITE_DOMAIN,	/* domain over determinable rowtype result */
-	TYPEFUNC_RECORD,			/* indeterminate rowtype result */
-	TYPEFUNC_OTHER				/* bogus type, eg pseudotype */
-} TypeFuncClass;
-
-extern TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo,
-										  Oid *resultTypeId,
-										  TupleDesc *resultTupleDesc);
-extern TypeFuncClass get_expr_result_type(Node *expr,
-										  Oid *resultTypeId,
-										  TupleDesc *resultTupleDesc);
-extern TypeFuncClass get_func_result_type(Oid functionId,
-										  Oid *resultTypeId,
-										  TupleDesc *resultTupleDesc);
-
-extern TupleDesc get_expr_result_tupdesc(Node *expr, bool noError);
-
-extern bool resolve_polymorphic_argtypes(int numargs, Oid *argtypes,
-										 char *argmodes,
-										 Node *call_expr);
-
-extern int	get_func_arg_info(HeapTuple procTup,
-							  Oid **p_argtypes, char ***p_argnames,
-							  char **p_argmodes);
-
-extern int	get_func_input_arg_names(Datum proargnames, Datum proargmodes,
-									 char ***arg_names);
-
-extern int	get_func_trftypes(HeapTuple procTup, Oid **p_trftypes);
-extern char *get_func_result_name(Oid functionId);
-
-extern TupleDesc build_function_result_tupdesc_d(char prokind,
-												 Datum proallargtypes,
-												 Datum proargmodes,
-												 Datum proargnames);
-extern TupleDesc build_function_result_tupdesc_t(HeapTuple procTuple);
-
-
-/*----------
- *	Support to ease writing functions returning composite types
- *
- * External declarations:
- * TupleDesc BlessTupleDesc(TupleDesc tupdesc) - "Bless" a completed tuple
- *		descriptor so that it can be used to return properly labeled tuples.
- *		You need to call this if you are going to use heap_form_tuple directly.
- *		TupleDescGetAttInMetadata does it for you, however, so no need to call
- *		it if you call TupleDescGetAttInMetadata.
- * AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc) - Build an
- *		AttInMetadata struct based on the given TupleDesc. AttInMetadata can
- *		be used in conjunction with C strings to produce a properly formed
- *		tuple.
- * HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values) -
- *		build a HeapTuple given user data in C string form. values is an array
- *		of C strings, one for each attribute of the return tuple.
- * Datum HeapTupleHeaderGetDatum(HeapTupleHeader tuple) - convert a
- *		HeapTupleHeader to a Datum.
- *
- * Inline declarations:
- * HeapTupleGetDatum(HeapTuple tuple) - convert a HeapTuple to a Datum.
- *
- * Obsolete routines and macros:
- * TupleDesc RelationNameGetTupleDesc(const char *relname) - Use to get a
- *		TupleDesc based on a named relation.
- * TupleDesc TypeGetTupleDesc(Oid typeoid, List *colaliases) - Use to get a
- *		TupleDesc based on a type OID.
- * TupleGetDatum(TupleTableSlot *slot, HeapTuple tuple) - get a Datum
- *		given a tuple and a slot.
- *----------
- */
-
-extern TupleDesc RelationNameGetTupleDesc(const char *relname);
-extern TupleDesc TypeGetTupleDesc(Oid typeoid, List *colaliases);
-
-/* from execTuples.c */
-extern TupleDesc BlessTupleDesc(TupleDesc tupdesc);
-extern AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc);
-extern HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values);
-extern Datum HeapTupleHeaderGetDatum(HeapTupleHeader tuple);
-
-static inline Datum
-HeapTupleGetDatum(const HeapTupleData *tuple)
-{
-	return HeapTupleHeaderGetDatum(tuple->t_data);
-}
-
-/* obsolete version of above */
-#define TupleGetDatum(_slot, _tuple)	HeapTupleGetDatum(_tuple)
-
-
-/*----------
- *		Support for Set Returning Functions (SRFs)
- *
- * The basic API for SRFs using ValuePerCall mode looks something like this:
- *
- * Datum
- * my_Set_Returning_Function(PG_FUNCTION_ARGS)
- * {
- *	FuncCallContext    *funcctx;
- *	Datum				result;
- *	MemoryContext		oldcontext;
- *	<user defined declarations>
- *
- *	if (SRF_IS_FIRSTCALL())
- *	{
- *		funcctx = SRF_FIRSTCALL_INIT();
- *		// switch context when allocating stuff to be used in later calls
- *		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
- *		<user defined code>
- *		<if returning composite>
- *			<build TupleDesc, and perhaps AttInMetadata>
- *		<endif returning composite>
- *		<user defined code>
- *		// return to original context when allocating transient memory
- *		MemoryContextSwitchTo(oldcontext);
- *	}
- *	<user defined code>
- *	funcctx = SRF_PERCALL_SETUP();
- *	<user defined code>
- *
- *	if (funcctx->call_cntr < funcctx->max_calls)
- *	{
- *		<user defined code>
- *		<obtain result Datum>
- *		SRF_RETURN_NEXT(funcctx, result);
- *	}
- *	else
- *		SRF_RETURN_DONE(funcctx);
- * }
- *
- * NOTE: there is no guarantee that a SRF using ValuePerCall mode will be
- * run to completion; for example, a query with LIMIT might stop short of
- * fetching all the rows.  Therefore, do not expect that you can do resource
- * cleanup just before SRF_RETURN_DONE().  You need not worry about releasing
- * memory allocated in multi_call_memory_ctx, but holding file descriptors or
- * other non-memory resources open across calls is a bug.  SRFs that need
- * such resources should not use these macros, but instead populate a
- * tuplestore during a single call, as set up by InitMaterializedSRF() (see
- * fmgr/README).  Alternatively, set up a callback to release resources
- * at query shutdown, using RegisterExprContextCallback().
- *
- *----------
- */
-
-/* from funcapi.c */
-
-/* flag bits for InitMaterializedSRF() */
-#define MAT_SRF_USE_EXPECTED_DESC	0x01	/* use expectedDesc as tupdesc. */
-#define MAT_SRF_BLESS				0x02	/* "Bless" a tuple descriptor with
-											 * BlessTupleDesc(). */
-extern void InitMaterializedSRF(FunctionCallInfo fcinfo, bits32 flags);
-
-extern FuncCallContext *init_MultiFuncCall(PG_FUNCTION_ARGS);
-extern FuncCallContext *per_MultiFuncCall(PG_FUNCTION_ARGS);
-extern void end_MultiFuncCall(PG_FUNCTION_ARGS, FuncCallContext *funcctx);
-
-#define SRF_IS_FIRSTCALL() (fcinfo->flinfo->fn_extra == NULL)
-
-#define SRF_FIRSTCALL_INIT() init_MultiFuncCall(fcinfo)
-
-#define SRF_PERCALL_SETUP() per_MultiFuncCall(fcinfo)
-
-#define SRF_RETURN_NEXT(_funcctx, _result) \
-	do { \
-		ReturnSetInfo	   *rsi; \
-		(_funcctx)->call_cntr++; \
-		rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
-		rsi->isDone = ExprMultipleResult; \
-		PG_RETURN_DATUM(_result); \
-	} while (0)
-
-#define SRF_RETURN_NEXT_NULL(_funcctx) \
-	do { \
-		ReturnSetInfo	   *rsi; \
-		(_funcctx)->call_cntr++; \
-		rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
-		rsi->isDone = ExprMultipleResult; \
-		PG_RETURN_NULL(); \
-	} while (0)
-
-#define  SRF_RETURN_DONE(_funcctx) \
-	do { \
-		ReturnSetInfo	   *rsi; \
-		end_MultiFuncCall(fcinfo, _funcctx); \
-		rsi = (ReturnSetInfo *) fcinfo->resultinfo; \
-		rsi->isDone = ExprEndResult; \
-		PG_RETURN_NULL(); \
-	} while (0)
-
-/*----------
- *	Support to ease writing of functions dealing with VARIADIC inputs
- *----------
- *
- * This function extracts a set of argument values, types and NULL markers
- * for a given input function. This returns a set of data:
- * - **values includes the set of Datum values extracted.
- * - **types the data type OID for each element.
- * - **nulls tracks if an element is NULL.
- *
- * variadic_start indicates the argument number where the VARIADIC argument
- * starts.
- * convert_unknown set to true will enforce the conversion of arguments
- * with unknown data type to text.
- *
- * The return result is the number of elements stored, or -1 in the case of
- * "VARIADIC NULL".
- */
-extern int	extract_variadic_args(FunctionCallInfo fcinfo, int variadic_start,
-								  bool convert_unknown, Datum **args,
-								  Oid **types, bool **nulls);
-
-#endif							/* FUNCAPI_H */