pg_query 5.1.0 → 6.1.0

data/ext/pg_query/include/postgres/equalfuncs.funcs.c

@@ -3,7 +3,7 @@
  * equalfuncs.funcs.c
  *    Generated node infrastructure code
  *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * NOTES
@@ -64,6 +64,7 @@ _equalRangeVar(const RangeVar *a, const RangeVar *b)
 static bool
 _equalTableFunc(const TableFunc *a, const TableFunc *b)
 {
+	COMPARE_SCALAR_FIELD(functype);
 	COMPARE_NODE_FIELD(ns_uris);
 	COMPARE_NODE_FIELD(ns_names);
 	COMPARE_NODE_FIELD(docexpr);
@@ -74,7 +75,10 @@ _equalTableFunc(const TableFunc *a, const TableFunc *b)
 	COMPARE_NODE_FIELD(colcollations);
 	COMPARE_NODE_FIELD(colexprs);
 	COMPARE_NODE_FIELD(coldefexprs);
+	COMPARE_NODE_FIELD(colvalexprs);
+	COMPARE_NODE_FIELD(passingvalexprs);
 	COMPARE_BITMAPSET_FIELD(notnulls);
+	COMPARE_NODE_FIELD(plan);
 	COMPARE_SCALAR_FIELD(ordinalitycol);
 	COMPARE_LOCATION_FIELD(location);
 
@@ -168,6 +172,7 @@ _equalWindowFunc(const WindowFunc *a, const WindowFunc *b)
 	COMPARE_SCALAR_FIELD(inputcollid);
 	COMPARE_NODE_FIELD(args);
 	COMPARE_NODE_FIELD(aggfilter);
+	COMPARE_NODE_FIELD(runCondition);
 	COMPARE_SCALAR_FIELD(winref);
 	COMPARE_SCALAR_FIELD(winstar);
 	COMPARE_SCALAR_FIELD(winagg);
@@ -176,6 +181,27 @@ _equalWindowFunc(const WindowFunc *a, const WindowFunc *b)
 	return true;
 }
 
+static bool
+_equalWindowFuncRunCondition(const WindowFuncRunCondition *a, const WindowFuncRunCondition *b)
+{
+	COMPARE_SCALAR_FIELD(opno);
+	COMPARE_SCALAR_FIELD(inputcollid);
+	COMPARE_SCALAR_FIELD(wfunc_left);
+	COMPARE_NODE_FIELD(arg);
+
+	return true;
+}
+
+static bool
+_equalMergeSupportFunc(const MergeSupportFunc *a, const MergeSupportFunc *b)
+{
+	COMPARE_SCALAR_FIELD(msftype);
+	COMPARE_SCALAR_FIELD(msfcollid);
+	COMPARE_LOCATION_FIELD(location);
+
+	return true;
+}
+
 static bool
 _equalSubscriptingRef(const SubscriptingRef *a, const SubscriptingRef *b)
 {
@@ -596,6 +622,70 @@ _equalJsonIsPredicate(const JsonIsPredicate *a, const JsonIsPredicate *b)
 	return true;
 }
 
+static bool
+_equalJsonBehavior(const JsonBehavior *a, const JsonBehavior *b)
+{
+	COMPARE_SCALAR_FIELD(btype);
+	COMPARE_NODE_FIELD(expr);
+	COMPARE_SCALAR_FIELD(coerce);
+	COMPARE_LOCATION_FIELD(location);
+
+	return true;
+}
+
+static bool
+_equalJsonExpr(const JsonExpr *a, const JsonExpr *b)
+{
+	COMPARE_SCALAR_FIELD(op);
+	COMPARE_STRING_FIELD(column_name);
+	COMPARE_NODE_FIELD(formatted_expr);
+	COMPARE_NODE_FIELD(format);
+	COMPARE_NODE_FIELD(path_spec);
+	COMPARE_NODE_FIELD(returning);
+	COMPARE_NODE_FIELD(passing_names);
+	COMPARE_NODE_FIELD(passing_values);
+	COMPARE_NODE_FIELD(on_empty);
+	COMPARE_NODE_FIELD(on_error);
+	COMPARE_SCALAR_FIELD(use_io_coercion);
+	COMPARE_SCALAR_FIELD(use_json_coercion);
+	COMPARE_SCALAR_FIELD(wrapper);
+	COMPARE_SCALAR_FIELD(omit_quotes);
+	COMPARE_SCALAR_FIELD(collation);
+	COMPARE_LOCATION_FIELD(location);
+
+	return true;
+}
+
+static bool
+_equalJsonTablePath(const JsonTablePath *a, const JsonTablePath *b)
+{
+	COMPARE_NODE_FIELD(value);
+	COMPARE_STRING_FIELD(name);
+
+	return true;
+}
+
+static bool
+_equalJsonTablePathScan(const JsonTablePathScan *a, const JsonTablePathScan *b)
+{
+	COMPARE_NODE_FIELD(path);
+	COMPARE_SCALAR_FIELD(errorOnError);
+	COMPARE_NODE_FIELD(child);
+	COMPARE_SCALAR_FIELD(colMin);
+	COMPARE_SCALAR_FIELD(colMax);
+
+	return true;
+}
+
+static bool
+_equalJsonTableSiblingJoin(const JsonTableSiblingJoin *a, const JsonTableSiblingJoin *b)
+{
+	COMPARE_NODE_FIELD(lplan);
+	COMPARE_NODE_FIELD(rplan);
+
+	return true;
+}
+
 static bool
 _equalNullTest(const NullTest *a, const NullTest *b)
 {
@@ -617,6 +707,19 @@ _equalBooleanTest(const BooleanTest *a, const BooleanTest *b)
 	return true;
 }
 
+static bool
+_equalMergeAction(const MergeAction *a, const MergeAction *b)
+{
+	COMPARE_SCALAR_FIELD(matchKind);
+	COMPARE_SCALAR_FIELD(commandType);
+	COMPARE_SCALAR_FIELD(override);
+	COMPARE_NODE_FIELD(qual);
+	COMPARE_NODE_FIELD(targetList);
+	COMPARE_NODE_FIELD(updateColnos);
+
+	return true;
+}
+
 static bool
 _equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b)
 {
@@ -765,7 +868,8 @@ _equalQuery(const Query *a, const Query *b)
 	COMPARE_NODE_FIELD(rteperminfos);
 	COMPARE_NODE_FIELD(jointree);
 	COMPARE_NODE_FIELD(mergeActionList);
-	COMPARE_SCALAR_FIELD(mergeUseOuterJoin);
+	COMPARE_SCALAR_FIELD(mergeTargetRelation);
+	COMPARE_NODE_FIELD(mergeJoinCondition);
 	COMPARE_NODE_FIELD(targetList);
 	COMPARE_SCALAR_FIELD(override);
 	COMPARE_NODE_FIELD(onConflict);
@@ -785,7 +889,7 @@ _equalQuery(const Query *a, const Query *b)
 	COMPARE_NODE_FIELD(constraintDeps);
 	COMPARE_NODE_FIELD(withCheckOptions);
 	COMPARE_LOCATION_FIELD(stmt_location);
-	COMPARE_SCALAR_FIELD(stmt_len);
+	COMPARE_LOCATION_FIELD(stmt_len);
 
 	return true;
 }
@@ -1160,6 +1264,13 @@ _equalPartitionRangeDatum(const PartitionRangeDatum *a, const PartitionRangeDatu
 	return true;
 }
 
+static bool
+_equalSinglePartitionSpec(const SinglePartitionSpec *a, const SinglePartitionSpec *b)
+{
+
+	return true;
+}
+
 static bool
 _equalPartitionCmd(const PartitionCmd *a, const PartitionCmd *b)
 {
@@ -1173,12 +1284,15 @@ _equalPartitionCmd(const PartitionCmd *a, const PartitionCmd *b)
 static bool
 _equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b)
 {
+	COMPARE_NODE_FIELD(alias);
+	COMPARE_NODE_FIELD(eref);
 	COMPARE_SCALAR_FIELD(rtekind);
 	COMPARE_SCALAR_FIELD(relid);
+	COMPARE_SCALAR_FIELD(inh);
 	COMPARE_SCALAR_FIELD(relkind);
 	COMPARE_SCALAR_FIELD(rellockmode);
-	COMPARE_NODE_FIELD(tablesample);
 	COMPARE_SCALAR_FIELD(perminfoindex);
+	COMPARE_NODE_FIELD(tablesample);
 	COMPARE_NODE_FIELD(subquery);
 	COMPARE_SCALAR_FIELD(security_barrier);
 	COMPARE_SCALAR_FIELD(jointype);
@@ -1199,10 +1313,7 @@ _equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b)
 	COMPARE_NODE_FIELD(colcollations);
 	COMPARE_STRING_FIELD(enrname);
 	COMPARE_SCALAR_FIELD(enrtuples);
-	COMPARE_NODE_FIELD(alias);
-	COMPARE_NODE_FIELD(eref);
 	COMPARE_SCALAR_FIELD(lateral);
-	COMPARE_SCALAR_FIELD(inh);
 	COMPARE_SCALAR_FIELD(inFromCl);
 	COMPARE_NODE_FIELD(securityQuals);
 
@@ -1291,7 +1402,6 @@ _equalWindowClause(const WindowClause *a, const WindowClause *b)
 	COMPARE_SCALAR_FIELD(frameOptions);
 	COMPARE_NODE_FIELD(startOffset);
 	COMPARE_NODE_FIELD(endOffset);
-	COMPARE_NODE_FIELD(runCondition);
 	COMPARE_SCALAR_FIELD(startInRangeFunc);
 	COMPARE_SCALAR_FIELD(endInRangeFunc);
 	COMPARE_SCALAR_FIELD(inRangeColl);
@@ -1398,7 +1508,7 @@ _equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b)
 static bool
 _equalMergeWhenClause(const MergeWhenClause *a, const MergeWhenClause *b)
 {
-	COMPARE_SCALAR_FIELD(matched);
+	COMPARE_SCALAR_FIELD(matchKind);
 	COMPARE_SCALAR_FIELD(commandType);
 	COMPARE_SCALAR_FIELD(override);
 	COMPARE_NODE_FIELD(condition);
@@ -1409,33 +1519,91 @@ _equalMergeWhenClause(const MergeWhenClause *a, const MergeWhenClause *b)
 }
 
 static bool
-_equalMergeAction(const MergeAction *a, const MergeAction *b)
+_equalTriggerTransition(const TriggerTransition *a, const TriggerTransition *b)
 {
-	COMPARE_SCALAR_FIELD(matched);
-	COMPARE_SCALAR_FIELD(commandType);
-	COMPARE_SCALAR_FIELD(override);
-	COMPARE_NODE_FIELD(qual);
-	COMPARE_NODE_FIELD(targetList);
-	COMPARE_NODE_FIELD(updateColnos);
+	COMPARE_STRING_FIELD(name);
+	COMPARE_SCALAR_FIELD(isNew);
+	COMPARE_SCALAR_FIELD(isTable);
 
 	return true;
 }
 
 static bool
-_equalTriggerTransition(const TriggerTransition *a, const TriggerTransition *b)
+_equalJsonOutput(const JsonOutput *a, const JsonOutput *b)
+{
+	COMPARE_NODE_FIELD(typeName);
+	COMPARE_NODE_FIELD(returning);
+
+	return true;
+}
+
+static bool
+_equalJsonArgument(const JsonArgument *a, const JsonArgument *b)
 {
+	COMPARE_NODE_FIELD(val);
 	COMPARE_STRING_FIELD(name);
-	COMPARE_SCALAR_FIELD(isNew);
-	COMPARE_SCALAR_FIELD(isTable);
 
 	return true;
 }
 
 static bool
-_equalJsonOutput(const JsonOutput *a, const JsonOutput *b)
+_equalJsonFuncExpr(const JsonFuncExpr *a, const JsonFuncExpr *b)
+{
+	COMPARE_SCALAR_FIELD(op);
+	COMPARE_STRING_FIELD(column_name);
+	COMPARE_NODE_FIELD(context_item);
+	COMPARE_NODE_FIELD(pathspec);
+	COMPARE_NODE_FIELD(passing);
+	COMPARE_NODE_FIELD(output);
+	COMPARE_NODE_FIELD(on_empty);
+	COMPARE_NODE_FIELD(on_error);
+	COMPARE_SCALAR_FIELD(wrapper);
+	COMPARE_SCALAR_FIELD(quotes);
+	COMPARE_LOCATION_FIELD(location);
+
+	return true;
+}
+
+static bool
+_equalJsonTablePathSpec(const JsonTablePathSpec *a, const JsonTablePathSpec *b)
+{
+	COMPARE_NODE_FIELD(string);
+	COMPARE_STRING_FIELD(name);
+	COMPARE_LOCATION_FIELD(name_location);
+	COMPARE_LOCATION_FIELD(location);
+
+	return true;
+}
+
+static bool
+_equalJsonTable(const JsonTable *a, const JsonTable *b)
 {
+	COMPARE_NODE_FIELD(context_item);
+	COMPARE_NODE_FIELD(pathspec);
+	COMPARE_NODE_FIELD(passing);
+	COMPARE_NODE_FIELD(columns);
+	COMPARE_NODE_FIELD(on_error);
+	COMPARE_NODE_FIELD(alias);
+	COMPARE_SCALAR_FIELD(lateral);
+	COMPARE_LOCATION_FIELD(location);
+
+	return true;
+}
+
+static bool
+_equalJsonTableColumn(const JsonTableColumn *a, const JsonTableColumn *b)
+{
+	COMPARE_SCALAR_FIELD(coltype);
+	COMPARE_STRING_FIELD(name);
 	COMPARE_NODE_FIELD(typeName);
-	COMPARE_NODE_FIELD(returning);
+	COMPARE_NODE_FIELD(pathspec);
+	COMPARE_NODE_FIELD(format);
+	COMPARE_SCALAR_FIELD(wrapper);
+	COMPARE_SCALAR_FIELD(quotes);
+	COMPARE_NODE_FIELD(columns);
+	COMPARE_NODE_FIELD(on_empty);
+	COMPARE_NODE_FIELD(on_error);
+	COMPARE_LOCATION_FIELD(location);
 
 	return true;
 }
@@ -1449,6 +1617,37 @@ _equalJsonKeyValue(const JsonKeyValue *a, const JsonKeyValue *b)
 	return true;
 }
 
+static bool
+_equalJsonParseExpr(const JsonParseExpr *a, const JsonParseExpr *b)
+{
+	COMPARE_NODE_FIELD(expr);
+	COMPARE_NODE_FIELD(output);
+	COMPARE_SCALAR_FIELD(unique_keys);
+	COMPARE_LOCATION_FIELD(location);
+
+	return true;
+}
+
+static bool
+_equalJsonScalarExpr(const JsonScalarExpr *a, const JsonScalarExpr *b)
+{
+	COMPARE_NODE_FIELD(expr);
+	COMPARE_NODE_FIELD(output);
+	COMPARE_LOCATION_FIELD(location);
+
+	return true;
+}
+
+static bool
+_equalJsonSerializeExpr(const JsonSerializeExpr *a, const JsonSerializeExpr *b)
+{
+	COMPARE_NODE_FIELD(expr);
+	COMPARE_NODE_FIELD(output);
+	COMPARE_LOCATION_FIELD(location);
+
+	return true;
+}
+
 static bool
 _equalJsonObjectConstructor(const JsonObjectConstructor *a, const JsonObjectConstructor *b)
 {
@@ -1522,7 +1721,7 @@ _equalRawStmt(const RawStmt *a, const RawStmt *b)
 {
 	COMPARE_NODE_FIELD(stmt);
 	COMPARE_LOCATION_FIELD(stmt_location);
-	COMPARE_SCALAR_FIELD(stmt_len);
+	COMPARE_LOCATION_FIELD(stmt_len);
 
 	return true;
 }
@@ -1573,6 +1772,7 @@ _equalMergeStmt(const MergeStmt *a, const MergeStmt *b)
 	COMPARE_NODE_FIELD(sourceRelation);
 	COMPARE_NODE_FIELD(joinCondition);
 	COMPARE_NODE_FIELD(mergeWhenClauses);
+	COMPARE_NODE_FIELD(returningList);
 	COMPARE_NODE_FIELD(withClause);
 
 	return true;
@@ -1825,11 +2025,13 @@ _equalConstraint(const Constraint *a, const Constraint *b)
 	COMPARE_STRING_FIELD(conname);
 	COMPARE_SCALAR_FIELD(deferrable);
 	COMPARE_SCALAR_FIELD(initdeferred);
-	COMPARE_LOCATION_FIELD(location);
+	COMPARE_SCALAR_FIELD(skip_validation);
+	COMPARE_SCALAR_FIELD(initially_valid);
 	COMPARE_SCALAR_FIELD(is_no_inherit);
 	COMPARE_NODE_FIELD(raw_expr);
 	COMPARE_STRING_FIELD(cooked_expr);
 	COMPARE_SCALAR_FIELD(generated_when);
+	COMPARE_SCALAR_FIELD(inhcount);
 	COMPARE_SCALAR_FIELD(nulls_not_distinct);
 	COMPARE_NODE_FIELD(keys);
 	COMPARE_NODE_FIELD(including);
@@ -1849,8 +2051,7 @@ _equalConstraint(const Constraint *a, const Constraint *b)
 	COMPARE_NODE_FIELD(fk_del_set_cols);
 	COMPARE_NODE_FIELD(old_conpfeqop);
 	COMPARE_SCALAR_FIELD(old_pktable_oid);
-	COMPARE_SCALAR_FIELD(skip_validation);
-	COMPARE_SCALAR_FIELD(initially_valid);
+	COMPARE_LOCATION_FIELD(location);
 
 	return true;
 }
@@ -2390,7 +2591,7 @@ static bool
 _equalAlterStatsStmt(const AlterStatsStmt *a, const AlterStatsStmt *b)
 {
 	COMPARE_NODE_FIELD(defnames);
-	COMPARE_SCALAR_FIELD(stxstattarget);
+	COMPARE_NODE_FIELD(stxstattarget);
 	COMPARE_SCALAR_FIELD(missing_ok);
 
 	return true;
@@ -2564,6 +2765,7 @@ _equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b)
 	COMPARE_STRING_FIELD(savepoint_name);
 	COMPARE_STRING_FIELD(gid);
 	COMPARE_SCALAR_FIELD(chain);
+	COMPARE_LOCATION_FIELD(location);
 
 	return true;
 }
@@ -2847,6 +3049,8 @@ static bool
 _equalDeallocateStmt(const DeallocateStmt *a, const DeallocateStmt *b)
 {
 	COMPARE_STRING_FIELD(name);
+	COMPARE_SCALAR_FIELD(isall);
+	COMPARE_LOCATION_FIELD(location);
 
 	return true;
 }
@@ -2980,6 +3184,15 @@ _equalPathKey(const PathKey *a, const PathKey *b)
 	return true;
 }
 
+static bool
+_equalGroupByOrdering(const GroupByOrdering *a, const GroupByOrdering *b)
+{
+	COMPARE_NODE_FIELD(pathkeys);
+	COMPARE_NODE_FIELD(clauses);
+
+	return true;
+}
+
 static bool
 _equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b)
 {

data/ext/pg_query/include/postgres/equalfuncs.switch.c

@@ -3,7 +3,7 @@
  * equalfuncs.switch.c
  *    Generated node infrastructure code
  *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * NOTES
@@ -45,6 +45,12 @@
 		case T_WindowFunc:
 			retval = _equalWindowFunc(a, b);
 			break;
+		case T_WindowFuncRunCondition:
+			retval = _equalWindowFuncRunCondition(a, b);
+			break;
+		case T_MergeSupportFunc:
+			retval = _equalMergeSupportFunc(a, b);
+			break;
 		case T_SubscriptingRef:
 			retval = _equalSubscriptingRef(a, b);
 			break;
@@ -144,12 +150,30 @@
 		case T_JsonIsPredicate:
 			retval = _equalJsonIsPredicate(a, b);
 			break;
+		case T_JsonBehavior:
+			retval = _equalJsonBehavior(a, b);
+			break;
+		case T_JsonExpr:
+			retval = _equalJsonExpr(a, b);
+			break;
+		case T_JsonTablePath:
+			retval = _equalJsonTablePath(a, b);
+			break;
+		case T_JsonTablePathScan:
+			retval = _equalJsonTablePathScan(a, b);
+			break;
+		case T_JsonTableSiblingJoin:
+			retval = _equalJsonTableSiblingJoin(a, b);
+			break;
 		case T_NullTest:
 			retval = _equalNullTest(a, b);
 			break;
 		case T_BooleanTest:
 			retval = _equalBooleanTest(a, b);
 			break;
+		case T_MergeAction:
+			retval = _equalMergeAction(a, b);
+			break;
 		case T_CoerceToDomain:
 			retval = _equalCoerceToDomain(a, b);
 			break;
@@ -282,6 +306,9 @@
 		case T_PartitionRangeDatum:
 			retval = _equalPartitionRangeDatum(a, b);
 			break;
+		case T_SinglePartitionSpec:
+			retval = _equalSinglePartitionSpec(a, b);
+			break;
 		case T_PartitionCmd:
 			retval = _equalPartitionCmd(a, b);
 			break;
@@ -333,18 +360,39 @@
 		case T_MergeWhenClause:
 			retval = _equalMergeWhenClause(a, b);
 			break;
-		case T_MergeAction:
-			retval = _equalMergeAction(a, b);
-			break;
 		case T_TriggerTransition:
 			retval = _equalTriggerTransition(a, b);
 			break;
 		case T_JsonOutput:
 			retval = _equalJsonOutput(a, b);
 			break;
+		case T_JsonArgument:
+			retval = _equalJsonArgument(a, b);
+			break;
+		case T_JsonFuncExpr:
+			retval = _equalJsonFuncExpr(a, b);
+			break;
+		case T_JsonTablePathSpec:
+			retval = _equalJsonTablePathSpec(a, b);
+			break;
+		case T_JsonTable:
+			retval = _equalJsonTable(a, b);
+			break;
+		case T_JsonTableColumn:
+			retval = _equalJsonTableColumn(a, b);
+			break;
 		case T_JsonKeyValue:
 			retval = _equalJsonKeyValue(a, b);
 			break;
+		case T_JsonParseExpr:
+			retval = _equalJsonParseExpr(a, b);
+			break;
+		case T_JsonScalarExpr:
+			retval = _equalJsonScalarExpr(a, b);
+			break;
+		case T_JsonSerializeExpr:
+			retval = _equalJsonSerializeExpr(a, b);
+			break;
 		case T_JsonObjectConstructor:
 			retval = _equalJsonObjectConstructor(a, b);
 			break;
@@ -747,6 +795,9 @@
 		case T_PathKey:
 			retval = _equalPathKey(a, b);
 			break;
+		case T_GroupByOrdering:
+			retval = _equalGroupByOrdering(a, b);
+			break;
 		case T_RestrictInfo:
 			retval = _equalRestrictInfo(a, b);
 			break;

data/ext/pg_query/include/postgres/executor/execdesc.h

@@ -5,7 +5,7 @@
  *	  and related modules.
  *
  *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * src/include/executor/execdesc.h
@@ -48,7 +48,7 @@ typedef struct QueryDesc
 	EState	   *estate;			/* executor's query-wide state */
 	PlanState  *planstate;		/* tree of per-plan-node state */
 
-	/* This field is set by ExecutorRun */
+	/* This field is set by ExecutePlan */
 	bool		already_executed;	/* true if previously executed */
 
 	/* This is always set NULL by the core system, but plugins can change it */

data/ext/pg_query/include/postgres/executor/executor.h

@@ -4,7 +4,7 @@
  *	  support for the POSTGRES executor module
  *
  *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * src/include/executor/executor.h
@@ -210,7 +210,8 @@ extern void standard_ExecutorEnd(QueryDesc *queryDesc);
 extern void ExecutorRewind(QueryDesc *queryDesc);
 extern bool ExecCheckPermissions(List *rangeTable,
 								 List *rteperminfos, bool ereport_on_violation);
-extern void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation);
+extern void CheckValidResultRel(ResultRelInfo *resultRelInfo, CmdType operation,
+								List *mergeActions);
 extern void InitResultRelInfo(ResultRelInfo *resultRelInfo,
 							  Relation resultRelationDesc,
 							  Index resultRelationIndex,
@@ -509,7 +510,7 @@ typedef struct TupOutputState
 extern TupOutputState *begin_tup_output_tupdesc(DestReceiver *dest,
 												TupleDesc tupdesc,
 												const TupleTableSlotOps *tts_ops);
-extern void do_tup_output(TupOutputState *tstate, Datum *values, bool *isnull);
+extern void do_tup_output(TupOutputState *tstate, const Datum *values, const bool *isnull);
 extern void do_text_output_multiline(TupOutputState *tstate, const char *txt);
 extern void end_tup_output(TupOutputState *tstate);
 
@@ -569,7 +570,6 @@ extern void ExecAssignProjectionInfo(PlanState *planstate,
 									 TupleDesc inputDesc);
 extern void ExecConditionalAssignProjectionInfo(PlanState *planstate,
 												TupleDesc inputDesc, int varno);
-extern void ExecFreeExprContext(PlanState *planstate);
 extern void ExecAssignScanType(ScanState *scanstate, TupleDesc tupDesc);
 extern void ExecCreateScanSlotFromOuterPlan(EState *estate,
 											ScanState *scanstate,
@@ -640,12 +640,13 @@ extern bool ExecCheckIndexConstraints(ResultRelInfo *resultRelInfo,
 extern void check_exclusion_constraint(Relation heap, Relation index,
 									   IndexInfo *indexInfo,
 									   ItemPointer tupleid,
-									   Datum *values, bool *isnull,
+									   const Datum *values, const bool *isnull,
 									   EState *estate, bool newIndex);
 
 /*
  * prototypes from functions in execReplication.c
  */
+extern StrategyNumber get_equal_strategy_number_for_am(Oid am);
 extern bool RelationFindReplTupleByIndex(Relation rel, Oid idxoid,
 										 LockTupleMode lockmode,
 										 TupleTableSlot *searchslot,

data/ext/pg_query/include/postgres/executor/functions.h

@@ -4,7 +4,7 @@
  *		Declarations for execution of SQL-language functions.
  *
  *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * src/include/executor/functions.h
@@ -47,6 +47,7 @@ extern void check_sql_fn_statements(List *queryTreeLists);
 
 extern bool check_sql_fn_retval(List *queryTreeLists,
 								Oid rettype, TupleDesc rettupdesc,
+								char prokind,
 								bool insertDroppedCols,
 								List **resultTargetList);
 

data/ext/pg_query/include/postgres/executor/instrument.h

@@ -4,7 +4,7 @@
  *	  definitions for run-time statistics collection
  *
  *
- * Copyright (c) 2001-2023, PostgreSQL Global Development Group
+ * Copyright (c) 2001-2024, PostgreSQL Global Development Group
  *
  * src/include/executor/instrument.h
  *
@@ -33,8 +33,10 @@ typedef struct BufferUsage
 	int64		local_blks_written; /* # of local disk blocks written */
 	int64		temp_blks_read; /* # of temp blocks read */
 	int64		temp_blks_written;	/* # of temp blocks written */
-	instr_time	blk_read_time;	/* time spent reading blocks */
-	instr_time	blk_write_time; /* time spent writing blocks */
+	instr_time	shared_blk_read_time;	/* time spent reading shared blocks */
+	instr_time	shared_blk_write_time;	/* time spent writing shared blocks */
+	instr_time	local_blk_read_time;	/* time spent reading local blocks */
+	instr_time	local_blk_write_time;	/* time spent writing local blocks */
 	instr_time	temp_blk_read_time; /* time spent reading temp blocks */
 	instr_time	temp_blk_write_time;	/* time spent writing temp blocks */
 } BufferUsage;

data/ext/pg_query/include/postgres/executor/spi.h

@@ -3,7 +3,7 @@
  * spi.h
  *				Server Programming Interface public declarations
  *
- * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * src/include/executor/spi.h
@@ -97,16 +97,10 @@ typedef struct _SPI_plan *SPIPlanPtr;
 #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)
 
-/* 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;