yb_ddl_parser 0.1.0

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeSubplan.h

@@ -0,0 +1,29 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeSubplan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2022, 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 */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeSubqueryscan.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeSubqueryscan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2022, 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 */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeTableFuncscan.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeTableFuncscan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2022, 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 */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeTidrangescan.h

@@ -0,0 +1,24 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeTidrangescan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2022, 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 */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeTidscan.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeTidscan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2022, 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 */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeUnique.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeUnique.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2022, 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 */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeValuesscan.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeValuesscan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2022, 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 ExecEndValuesScan(ValuesScanState *node);
+extern void ExecReScanValuesScan(ValuesScanState *node);
+
+#endif							/* NODEVALUESSCAN_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeWindowAgg.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeWindowAgg.h
+ *	  prototypes for nodeWindowAgg.c
+ *
+ *
+ * Portions Copyright (c) 1996-2022, 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 */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeWorktablescan.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeWorktablescan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2022, 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 ExecEndWorkTableScan(WorkTableScanState *node);
+extern void ExecReScanWorkTableScan(WorkTableScanState *node);
+
+#endif							/* NODEWORKTABLESCAN_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeYbBatchedNestloop.h

@@ -0,0 +1,33 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeYbBatchedNestLoop.h
+ *	  Implementation of Yugabyte's batched nested loop join.
+ *
+ * Copyright (c) YugabyteDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied.  See the License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * src/postgres/src/include/executor/nodeYbBatchedNestloop.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef NODEYBBATCHEDNESTLOOP_H
+#define NODEYBBATCHEDNESTLOOP_H
+
+#include "nodes/execnodes.h"
+
+
+extern YbBatchedNestLoopState *ExecInitYbBatchedNestLoop(YbBatchedNestLoop *node, EState *estate, int eflags);
+extern void ExecEndYbBatchedNestLoop(YbBatchedNestLoopState *node);
+extern void ExecReScanYbBatchedNestLoop(YbBatchedNestLoopState *node);
+
+#endif							/* NODEYBBATCHEDNESTLOOP_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeYbBitmapIndexscan.h

@@ -0,0 +1,24 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeYbBitmapIndexscan.h
+ *
+ *
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeYbBitmapIndexscan.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODEYBBITMAPINDEXSCAN_H
+#define NODEYBBITMAPINDEXSCAN_H
+
+#include "nodes/execnodes.h"
+
+extern YbBitmapIndexScanState *ExecInitYbBitmapIndexScan(YbBitmapIndexScan *node, EState *estate, int eflags);
+extern Node *MultiExecYbBitmapIndexScan(YbBitmapIndexScanState *node);
+extern void ExecEndYbBitmapIndexScan(YbBitmapIndexScanState *node);
+extern void ExecReScanYbBitmapIndexScan(YbBitmapIndexScanState *node);
+
+#endif							/* NODEYBBITMAPINDEXSCAN_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeYbBitmapTablescan.h

@@ -0,0 +1,22 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeYbBitmapTablescan.h
+ *
+ * Copyright (c) 2024 YugabyteDB, Inc
+ *
+ * src/include/executor/nodeYbBitmapTablescan.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODEYBBITMAPTABLESCAN_H
+#define NODEYBBITMAPTABLESCAN_H
+
+#include "nodes/execnodes.h"
+
+extern YbBitmapTableScanState *ExecInitYbBitmapTableScan(YbBitmapTableScan *node,
+														 EState *estate,
+														 int eflags);
+extern void ExecEndYbBitmapTableScan(YbBitmapTableScanState *node);
+extern void ExecReScanYbBitmapTableScan(YbBitmapTableScanState *node);
+
+#endif							/* NODEYBBITMAPTABLESCAN_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/nodeYbSeqscan.h

@@ -0,0 +1,45 @@
+/*-------------------------------------------------------------------------
+ *
+ * nodeYbSeqscan.h
+ *
+ * Copyright (c) YugabyteDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied.  See the License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/nodeYbSeqscan.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NODEYBSEQSCAN_H
+#define NODEYBSEQSCAN_H
+
+#include "access/parallel.h"
+#include "nodes/execnodes.h"
+
+extern YbSeqScanState *ExecInitYbSeqScan(YbSeqScan *node, EState *estate,
+										 int eflags);
+extern void ExecEndYbSeqScan(YbSeqScanState *node);
+extern void ExecReScanYbSeqScan(YbSeqScanState *node);
+
+/* parallel scan support */
+extern void ExecYbSeqScanEstimate(YbSeqScanState *node,
+								  ParallelContext *pcxt);
+extern void ExecYbSeqScanInitializeDSM(YbSeqScanState *node,
+									   ParallelContext *pcxt);
+extern void ExecYbSeqScanReInitializeDSM(YbSeqScanState *node,
+										 ParallelContext *pcxt);
+extern void ExecYbSeqScanInitializeWorker(YbSeqScanState *node,
+										  ParallelWorkerContext *pwcxt);
+
+#endif							/* NODEYBSEQSCAN_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/spi.h

@@ -0,0 +1,214 @@
+/*-------------------------------------------------------------------------
+ *
+ * spi.h
+ *				Server Programming Interface public declarations
+ *
+ * Portions Copyright (c) 1996-2022, 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;
+	bool		yb_reuse_existing_snapshot_in_read_committed;
+} 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_OPT_NONATOMIC		(1 << 0)
+
+/* These used to be functions, now just no-ops for backwards compatibility */
+#define SPI_push()	((void) 0)
+#define SPI_pop()	((void) 0)
+#define SPI_push_conditional()	false
+#define SPI_pop_conditional(pushed) ((void) 0)
+#define SPI_restore_connection()	((void) 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 pointer);
+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 */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/spi_priv.h

@@ -0,0 +1,105 @@
+/*-------------------------------------------------------------------------
+ *
+ * spi_priv.h
+ *				Server Programming Interface private declarations
+ *
+ * Portions Copyright (c) 1996-2022, 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 */