From 2be87f092a2ac786264b2020797aafa837de5a8e Mon Sep 17 00:00:00 2001 From: Peter Eisentraut Date: Sat, 9 Jul 2022 15:06:01 +0200 Subject: [PATCH] Remove code sections obsoleted by node support automation This removes the code sections that were ifdef'ed out by 964d01ae90c314eb31132c2e7712d5d9fc237331. --- src/backend/nodes/copyfuncs.c | 6357 +------------------------------- src/backend/nodes/equalfuncs.c | 4206 +-------------------- src/backend/nodes/outfuncs.c | 3908 +------------------- src/backend/nodes/readfuncs.c | 2744 +------------- src/include/nodes/nodes.h | 531 --- 5 files changed, 9 insertions(+), 17737 deletions(-) diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index b72c79f2df..b8e40a4195 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -3,13 +3,6 @@ * copyfuncs.c * Copy functions for Postgres tree nodes. * - * NOTE: we currently support copying all node types found in parse and - * plan trees. We do not support copying executor state trees; there - * is no need for that, and no point in maintaining all the code that - * would be needed. We also do not support copying Path trees, mainly - * because the circular linkages between RelOptInfo and Path nodes can't - * be handled easily in a simple depth-first traversal. - * * * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California @@ -71,1370 +64,11 @@ #include "copyfuncs.funcs.c" -#ifdef OBSOLETE -/* **************************************************************** - * plannodes.h copy functions - * **************************************************************** - */ /* - * _copyPlannedStmt - */ -static PlannedStmt * -_copyPlannedStmt(const PlannedStmt *from) -{ - PlannedStmt *newnode = makeNode(PlannedStmt); - - COPY_SCALAR_FIELD(commandType); - COPY_SCALAR_FIELD(queryId); - COPY_SCALAR_FIELD(hasReturning); - COPY_SCALAR_FIELD(hasModifyingCTE); - COPY_SCALAR_FIELD(canSetTag); - COPY_SCALAR_FIELD(transientPlan); - COPY_SCALAR_FIELD(dependsOnRole); - COPY_SCALAR_FIELD(parallelModeNeeded); - COPY_SCALAR_FIELD(jitFlags); - COPY_NODE_FIELD(planTree); - COPY_NODE_FIELD(rtable); - COPY_NODE_FIELD(resultRelations); - COPY_NODE_FIELD(appendRelations); - COPY_NODE_FIELD(subplans); - COPY_BITMAPSET_FIELD(rewindPlanIDs); - COPY_NODE_FIELD(rowMarks); - COPY_NODE_FIELD(relationOids); - COPY_NODE_FIELD(invalItems); - COPY_NODE_FIELD(paramExecTypes); - COPY_NODE_FIELD(utilityStmt); - COPY_LOCATION_FIELD(stmt_location); - COPY_SCALAR_FIELD(stmt_len); - - return newnode; -} - -/* - * CopyPlanFields - * - * This function copies the fields of the Plan node. It is used by - * all the copy functions for classes which inherit from Plan. - */ -static void -CopyPlanFields(const Plan *from, Plan *newnode) -{ - COPY_SCALAR_FIELD(startup_cost); - COPY_SCALAR_FIELD(total_cost); - COPY_SCALAR_FIELD(plan_rows); - COPY_SCALAR_FIELD(plan_width); - COPY_SCALAR_FIELD(parallel_aware); - COPY_SCALAR_FIELD(parallel_safe); - COPY_SCALAR_FIELD(async_capable); - COPY_SCALAR_FIELD(plan_node_id); - COPY_NODE_FIELD(targetlist); - COPY_NODE_FIELD(qual); - COPY_NODE_FIELD(lefttree); - COPY_NODE_FIELD(righttree); - COPY_NODE_FIELD(initPlan); - COPY_BITMAPSET_FIELD(extParam); - COPY_BITMAPSET_FIELD(allParam); -} - -/* - * _copyResult - */ -static Result * -_copyResult(const Result *from) -{ - Result *newnode = makeNode(Result); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(resconstantqual); - - return newnode; -} - -/* - * _copyProjectSet - */ -static ProjectSet * -_copyProjectSet(const ProjectSet *from) -{ - ProjectSet *newnode = makeNode(ProjectSet); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - return newnode; -} - -/* - * _copyModifyTable - */ -static ModifyTable * -_copyModifyTable(const ModifyTable *from) -{ - ModifyTable *newnode = makeNode(ModifyTable); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(operation); - COPY_SCALAR_FIELD(canSetTag); - COPY_SCALAR_FIELD(nominalRelation); - COPY_SCALAR_FIELD(rootRelation); - COPY_SCALAR_FIELD(partColsUpdated); - COPY_NODE_FIELD(resultRelations); - COPY_NODE_FIELD(updateColnosLists); - COPY_NODE_FIELD(withCheckOptionLists); - COPY_NODE_FIELD(returningLists); - COPY_NODE_FIELD(fdwPrivLists); - COPY_BITMAPSET_FIELD(fdwDirectModifyPlans); - COPY_NODE_FIELD(rowMarks); - COPY_SCALAR_FIELD(epqParam); - COPY_SCALAR_FIELD(onConflictAction); - COPY_NODE_FIELD(arbiterIndexes); - COPY_NODE_FIELD(onConflictSet); - COPY_NODE_FIELD(onConflictCols); - COPY_NODE_FIELD(onConflictWhere); - COPY_SCALAR_FIELD(exclRelRTI); - COPY_NODE_FIELD(exclRelTlist); - COPY_NODE_FIELD(mergeActionLists); - - return newnode; -} - -/* - * _copyAppend - */ -static Append * -_copyAppend(const Append *from) -{ - Append *newnode = makeNode(Append); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_BITMAPSET_FIELD(apprelids); - COPY_NODE_FIELD(appendplans); - COPY_SCALAR_FIELD(nasyncplans); - COPY_SCALAR_FIELD(first_partial_plan); - COPY_NODE_FIELD(part_prune_info); - - return newnode; -} - -/* - * _copyMergeAppend - */ -static MergeAppend * -_copyMergeAppend(const MergeAppend *from) -{ - MergeAppend *newnode = makeNode(MergeAppend); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_BITMAPSET_FIELD(apprelids); - COPY_NODE_FIELD(mergeplans); - COPY_SCALAR_FIELD(numCols); - COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool)); - COPY_NODE_FIELD(part_prune_info); - - return newnode; -} - -/* - * _copyRecursiveUnion - */ -static RecursiveUnion * -_copyRecursiveUnion(const RecursiveUnion *from) -{ - RecursiveUnion *newnode = makeNode(RecursiveUnion); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(wtParam); - COPY_SCALAR_FIELD(numCols); - COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid)); - COPY_SCALAR_FIELD(numGroups); - - return newnode; -} - -/* - * _copyBitmapAnd - */ -static BitmapAnd * -_copyBitmapAnd(const BitmapAnd *from) -{ - BitmapAnd *newnode = makeNode(BitmapAnd); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(bitmapplans); - - return newnode; -} - -/* - * _copyBitmapOr - */ -static BitmapOr * -_copyBitmapOr(const BitmapOr *from) -{ - BitmapOr *newnode = makeNode(BitmapOr); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(isshared); - COPY_NODE_FIELD(bitmapplans); - - return newnode; -} - -/* - * _copyGather - */ -static Gather * -_copyGather(const Gather *from) -{ - Gather *newnode = makeNode(Gather); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(num_workers); - COPY_SCALAR_FIELD(rescan_param); - COPY_SCALAR_FIELD(single_copy); - COPY_SCALAR_FIELD(invisible); - COPY_BITMAPSET_FIELD(initParam); - - return newnode; -} - -/* - * _copyGatherMerge - */ -static GatherMerge * -_copyGatherMerge(const GatherMerge *from) -{ - GatherMerge *newnode = makeNode(GatherMerge); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(num_workers); - COPY_SCALAR_FIELD(rescan_param); - COPY_SCALAR_FIELD(numCols); - COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool)); - COPY_BITMAPSET_FIELD(initParam); - - return newnode; -} - -/* - * CopyScanFields - * - * This function copies the fields of the Scan node. It is used by - * all the copy functions for classes which inherit from Scan. - */ -static void -CopyScanFields(const Scan *from, Scan *newnode) -{ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - COPY_SCALAR_FIELD(scanrelid); -} - -/* - * _copyScan - */ -static Scan * -_copyScan(const Scan *from) -{ - Scan *newnode = makeNode(Scan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - return newnode; -} - -/* - * _copySeqScan - */ -static SeqScan * -_copySeqScan(const SeqScan *from) -{ - SeqScan *newnode = makeNode(SeqScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - return newnode; -} - -/* - * _copySampleScan - */ -static SampleScan * -_copySampleScan(const SampleScan *from) -{ - SampleScan *newnode = makeNode(SampleScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(tablesample); - - return newnode; -} - -/* - * _copyIndexScan - */ -static IndexScan * -_copyIndexScan(const IndexScan *from) -{ - IndexScan *newnode = makeNode(IndexScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(indexid); - COPY_NODE_FIELD(indexqual); - COPY_NODE_FIELD(indexqualorig); - COPY_NODE_FIELD(indexorderby); - COPY_NODE_FIELD(indexorderbyorig); - COPY_NODE_FIELD(indexorderbyops); - COPY_SCALAR_FIELD(indexorderdir); - - return newnode; -} - -/* - * _copyIndexOnlyScan - */ -static IndexOnlyScan * -_copyIndexOnlyScan(const IndexOnlyScan *from) -{ - IndexOnlyScan *newnode = makeNode(IndexOnlyScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(indexid); - COPY_NODE_FIELD(indexqual); - COPY_NODE_FIELD(recheckqual); - COPY_NODE_FIELD(indexorderby); - COPY_NODE_FIELD(indextlist); - COPY_SCALAR_FIELD(indexorderdir); - - return newnode; -} - -/* - * _copyBitmapIndexScan - */ -static BitmapIndexScan * -_copyBitmapIndexScan(const BitmapIndexScan *from) -{ - BitmapIndexScan *newnode = makeNode(BitmapIndexScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(indexid); - COPY_SCALAR_FIELD(isshared); - COPY_NODE_FIELD(indexqual); - COPY_NODE_FIELD(indexqualorig); - - return newnode; -} - -/* - * _copyBitmapHeapScan - */ -static BitmapHeapScan * -_copyBitmapHeapScan(const BitmapHeapScan *from) -{ - BitmapHeapScan *newnode = makeNode(BitmapHeapScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(bitmapqualorig); - - return newnode; -} - -/* - * _copyTidScan - */ -static TidScan * -_copyTidScan(const TidScan *from) -{ - TidScan *newnode = makeNode(TidScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(tidquals); - - return newnode; -} - -/* - * _copyTidRangeScan - */ -static TidRangeScan * -_copyTidRangeScan(const TidRangeScan *from) -{ - TidRangeScan *newnode = makeNode(TidRangeScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(tidrangequals); - - return newnode; -} - -/* - * _copySubqueryScan - */ -static SubqueryScan * -_copySubqueryScan(const SubqueryScan *from) -{ - SubqueryScan *newnode = makeNode(SubqueryScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(subplan); - COPY_SCALAR_FIELD(scanstatus); - - return newnode; -} - -/* - * _copyFunctionScan - */ -static FunctionScan * -_copyFunctionScan(const FunctionScan *from) -{ - FunctionScan *newnode = makeNode(FunctionScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(functions); - COPY_SCALAR_FIELD(funcordinality); - - return newnode; -} - -/* - * _copyTableFuncScan - */ -static TableFuncScan * -_copyTableFuncScan(const TableFuncScan *from) -{ - TableFuncScan *newnode = makeNode(TableFuncScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(tablefunc); - - return newnode; -} - -/* - * _copyValuesScan - */ -static ValuesScan * -_copyValuesScan(const ValuesScan *from) -{ - ValuesScan *newnode = makeNode(ValuesScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(values_lists); - - return newnode; -} - -/* - * _copyCteScan - */ -static CteScan * -_copyCteScan(const CteScan *from) -{ - CteScan *newnode = makeNode(CteScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(ctePlanId); - COPY_SCALAR_FIELD(cteParam); - - return newnode; -} - -/* - * _copyNamedTuplestoreScan - */ -static NamedTuplestoreScan * -_copyNamedTuplestoreScan(const NamedTuplestoreScan *from) -{ - NamedTuplestoreScan *newnode = makeNode(NamedTuplestoreScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_STRING_FIELD(enrname); - - return newnode; -} - -/* - * _copyWorkTableScan - */ -static WorkTableScan * -_copyWorkTableScan(const WorkTableScan *from) -{ - WorkTableScan *newnode = makeNode(WorkTableScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(wtParam); - - return newnode; -} - -/* - * _copyForeignScan - */ -static ForeignScan * -_copyForeignScan(const ForeignScan *from) -{ - ForeignScan *newnode = makeNode(ForeignScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(operation); - COPY_SCALAR_FIELD(resultRelation); - COPY_SCALAR_FIELD(fs_server); - COPY_NODE_FIELD(fdw_exprs); - COPY_NODE_FIELD(fdw_private); - COPY_NODE_FIELD(fdw_scan_tlist); - COPY_NODE_FIELD(fdw_recheck_quals); - COPY_BITMAPSET_FIELD(fs_relids); - COPY_SCALAR_FIELD(fsSystemCol); - - return newnode; -} - -/* - * _copyCustomScan - */ -static CustomScan * -_copyCustomScan(const CustomScan *from) -{ - CustomScan *newnode = makeNode(CustomScan); - - /* - * copy node superclass fields - */ - CopyScanFields((const Scan *) from, (Scan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(flags); - COPY_NODE_FIELD(custom_plans); - COPY_NODE_FIELD(custom_exprs); - COPY_NODE_FIELD(custom_private); - COPY_NODE_FIELD(custom_scan_tlist); - COPY_BITMAPSET_FIELD(custom_relids); - - /* - * NOTE: The method field of CustomScan is required to be a pointer to a - * static table of callback functions. So we don't copy the table itself, - * just reference the original one. - */ - COPY_SCALAR_FIELD(methods); - - return newnode; -} - -/* - * CopyJoinFields - * - * This function copies the fields of the Join node. It is used by - * all the copy functions for classes which inherit from Join. - */ -static void -CopyJoinFields(const Join *from, Join *newnode) -{ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - COPY_SCALAR_FIELD(jointype); - COPY_SCALAR_FIELD(inner_unique); - COPY_NODE_FIELD(joinqual); -} - - -/* - * _copyNestLoop - */ -static NestLoop * -_copyNestLoop(const NestLoop *from) -{ - NestLoop *newnode = makeNode(NestLoop); - - /* - * copy node superclass fields - */ - CopyJoinFields((const Join *) from, (Join *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(nestParams); - - return newnode; -} - - -/* - * _copyMergeJoin - */ -static MergeJoin * -_copyMergeJoin(const MergeJoin *from) -{ - MergeJoin *newnode = makeNode(MergeJoin); - int numCols; - - /* - * copy node superclass fields - */ - CopyJoinFields((const Join *) from, (Join *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(skip_mark_restore); - COPY_NODE_FIELD(mergeclauses); - numCols = list_length(from->mergeclauses); - COPY_POINTER_FIELD(mergeFamilies, numCols * sizeof(Oid)); - COPY_POINTER_FIELD(mergeCollations, numCols * sizeof(Oid)); - COPY_POINTER_FIELD(mergeStrategies, numCols * sizeof(int)); - COPY_POINTER_FIELD(mergeNullsFirst, numCols * sizeof(bool)); - - return newnode; -} - -/* - * _copyHashJoin - */ -static HashJoin * -_copyHashJoin(const HashJoin *from) -{ - HashJoin *newnode = makeNode(HashJoin); - - /* - * copy node superclass fields - */ - CopyJoinFields((const Join *) from, (Join *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(hashclauses); - COPY_NODE_FIELD(hashoperators); - COPY_NODE_FIELD(hashcollations); - COPY_NODE_FIELD(hashkeys); - - return newnode; -} - - -/* - * _copyMaterial - */ -static Material * -_copyMaterial(const Material *from) -{ - Material *newnode = makeNode(Material); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - return newnode; -} - - -/* - * _copyMemoize - */ -static Memoize * -_copyMemoize(const Memoize *from) -{ - Memoize *newnode = makeNode(Memoize); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(numKeys); - COPY_POINTER_FIELD(hashOperators, sizeof(Oid) * from->numKeys); - COPY_POINTER_FIELD(collations, sizeof(Oid) * from->numKeys); - COPY_NODE_FIELD(param_exprs); - COPY_SCALAR_FIELD(singlerow); - COPY_SCALAR_FIELD(binary_mode); - COPY_SCALAR_FIELD(est_entries); - COPY_BITMAPSET_FIELD(keyparamids); - - return newnode; -} - - -/* - * CopySortFields - * - * This function copies the fields of the Sort node. It is used by - * all the copy functions for classes which inherit from Sort. - */ -static void -CopySortFields(const Sort *from, Sort *newnode) -{ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - COPY_SCALAR_FIELD(numCols); - COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool)); -} - -/* - * _copySort - */ -static Sort * -_copySort(const Sort *from) -{ - Sort *newnode = makeNode(Sort); - - /* - * copy node superclass fields - */ - CopySortFields(from, newnode); - - return newnode; -} - - -/* - * _copyIncrementalSort - */ -static IncrementalSort * -_copyIncrementalSort(const IncrementalSort *from) -{ - IncrementalSort *newnode = makeNode(IncrementalSort); - - /* - * copy node superclass fields - */ - CopySortFields((const Sort *) from, (Sort *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(nPresortedCols); - - return newnode; -} - - -/* - * _copyGroup - */ -static Group * -_copyGroup(const Group *from) -{ - Group *newnode = makeNode(Group); - - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - COPY_SCALAR_FIELD(numCols); - COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid)); - - return newnode; -} - -/* - * _copyAgg - */ -static Agg * -_copyAgg(const Agg *from) -{ - Agg *newnode = makeNode(Agg); - - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - COPY_SCALAR_FIELD(aggstrategy); - COPY_SCALAR_FIELD(aggsplit); - COPY_SCALAR_FIELD(numCols); - COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid)); - COPY_SCALAR_FIELD(numGroups); - COPY_SCALAR_FIELD(transitionSpace); - COPY_BITMAPSET_FIELD(aggParams); - COPY_NODE_FIELD(groupingSets); - COPY_NODE_FIELD(chain); - - return newnode; -} - -/* - * _copyWindowAgg - */ -static WindowAgg * -_copyWindowAgg(const WindowAgg *from) -{ - WindowAgg *newnode = makeNode(WindowAgg); - - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - COPY_SCALAR_FIELD(winref); - COPY_SCALAR_FIELD(partNumCols); - COPY_POINTER_FIELD(partColIdx, from->partNumCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(partOperators, from->partNumCols * sizeof(Oid)); - COPY_POINTER_FIELD(partCollations, from->partNumCols * sizeof(Oid)); - COPY_SCALAR_FIELD(ordNumCols); - COPY_POINTER_FIELD(ordColIdx, from->ordNumCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(ordOperators, from->ordNumCols * sizeof(Oid)); - COPY_POINTER_FIELD(ordCollations, from->ordNumCols * sizeof(Oid)); - COPY_SCALAR_FIELD(frameOptions); - COPY_NODE_FIELD(startOffset); - COPY_NODE_FIELD(endOffset); - COPY_NODE_FIELD(runCondition); - COPY_NODE_FIELD(runConditionOrig); - COPY_SCALAR_FIELD(startInRangeFunc); - COPY_SCALAR_FIELD(endInRangeFunc); - COPY_SCALAR_FIELD(inRangeColl); - COPY_SCALAR_FIELD(inRangeAsc); - COPY_SCALAR_FIELD(inRangeNullsFirst); - COPY_SCALAR_FIELD(topWindow); - - return newnode; -} - -/* - * _copyUnique - */ -static Unique * -_copyUnique(const Unique *from) -{ - Unique *newnode = makeNode(Unique); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(numCols); - COPY_POINTER_FIELD(uniqColIdx, from->numCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(uniqOperators, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(uniqCollations, from->numCols * sizeof(Oid)); - - return newnode; -} - -/* - * _copyHash - */ -static Hash * -_copyHash(const Hash *from) -{ - Hash *newnode = makeNode(Hash); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(hashkeys); - COPY_SCALAR_FIELD(skewTable); - COPY_SCALAR_FIELD(skewColumn); - COPY_SCALAR_FIELD(skewInherit); - COPY_SCALAR_FIELD(rows_total); - - return newnode; -} - -/* - * _copySetOp - */ -static SetOp * -_copySetOp(const SetOp *from) -{ - SetOp *newnode = makeNode(SetOp); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_SCALAR_FIELD(cmd); - COPY_SCALAR_FIELD(strategy); - COPY_SCALAR_FIELD(numCols); - COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid)); - COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid)); - COPY_SCALAR_FIELD(flagColIdx); - COPY_SCALAR_FIELD(firstFlag); - COPY_SCALAR_FIELD(numGroups); - - return newnode; -} - -/* - * _copyLockRows - */ -static LockRows * -_copyLockRows(const LockRows *from) -{ - LockRows *newnode = makeNode(LockRows); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(rowMarks); - COPY_SCALAR_FIELD(epqParam); - - return newnode; -} - -/* - * _copyLimit - */ -static Limit * -_copyLimit(const Limit *from) -{ - Limit *newnode = makeNode(Limit); - - /* - * copy node superclass fields - */ - CopyPlanFields((const Plan *) from, (Plan *) newnode); - - /* - * copy remainder of node - */ - COPY_NODE_FIELD(limitOffset); - COPY_NODE_FIELD(limitCount); - COPY_SCALAR_FIELD(limitOption); - COPY_SCALAR_FIELD(uniqNumCols); - COPY_POINTER_FIELD(uniqColIdx, from->uniqNumCols * sizeof(AttrNumber)); - COPY_POINTER_FIELD(uniqOperators, from->uniqNumCols * sizeof(Oid)); - COPY_POINTER_FIELD(uniqCollations, from->uniqNumCols * sizeof(Oid)); - - return newnode; -} - -/* - * _copyNestLoopParam - */ -static NestLoopParam * -_copyNestLoopParam(const NestLoopParam *from) -{ - NestLoopParam *newnode = makeNode(NestLoopParam); - - COPY_SCALAR_FIELD(paramno); - COPY_NODE_FIELD(paramval); - - return newnode; -} - -/* - * _copyPlanRowMark - */ -static PlanRowMark * -_copyPlanRowMark(const PlanRowMark *from) -{ - PlanRowMark *newnode = makeNode(PlanRowMark); - - COPY_SCALAR_FIELD(rti); - COPY_SCALAR_FIELD(prti); - COPY_SCALAR_FIELD(rowmarkId); - COPY_SCALAR_FIELD(markType); - COPY_SCALAR_FIELD(allMarkTypes); - COPY_SCALAR_FIELD(strength); - COPY_SCALAR_FIELD(waitPolicy); - COPY_SCALAR_FIELD(isParent); - - return newnode; -} - -static PartitionPruneInfo * -_copyPartitionPruneInfo(const PartitionPruneInfo *from) -{ - PartitionPruneInfo *newnode = makeNode(PartitionPruneInfo); - - COPY_NODE_FIELD(prune_infos); - COPY_BITMAPSET_FIELD(other_subplans); - - return newnode; -} - -static PartitionedRelPruneInfo * -_copyPartitionedRelPruneInfo(const PartitionedRelPruneInfo *from) -{ - PartitionedRelPruneInfo *newnode = makeNode(PartitionedRelPruneInfo); - - COPY_SCALAR_FIELD(rtindex); - COPY_BITMAPSET_FIELD(present_parts); - COPY_SCALAR_FIELD(nparts); - COPY_POINTER_FIELD(subplan_map, from->nparts * sizeof(int)); - COPY_POINTER_FIELD(subpart_map, from->nparts * sizeof(int)); - COPY_POINTER_FIELD(relid_map, from->nparts * sizeof(Oid)); - COPY_NODE_FIELD(initial_pruning_steps); - COPY_NODE_FIELD(exec_pruning_steps); - COPY_BITMAPSET_FIELD(execparamids); - - return newnode; -} - -/* - * _copyPartitionPruneStepOp - */ -static PartitionPruneStepOp * -_copyPartitionPruneStepOp(const PartitionPruneStepOp *from) -{ - PartitionPruneStepOp *newnode = makeNode(PartitionPruneStepOp); - - COPY_SCALAR_FIELD(step.step_id); - COPY_SCALAR_FIELD(opstrategy); - COPY_NODE_FIELD(exprs); - COPY_NODE_FIELD(cmpfns); - COPY_BITMAPSET_FIELD(nullkeys); - - return newnode; -} - -/* - * _copyPartitionPruneStepCombine - */ -static PartitionPruneStepCombine * -_copyPartitionPruneStepCombine(const PartitionPruneStepCombine *from) -{ - PartitionPruneStepCombine *newnode = makeNode(PartitionPruneStepCombine); - - COPY_SCALAR_FIELD(step.step_id); - COPY_SCALAR_FIELD(combineOp); - COPY_NODE_FIELD(source_stepids); - - return newnode; -} - -/* - * _copyPlanInvalItem - */ -static PlanInvalItem * -_copyPlanInvalItem(const PlanInvalItem *from) -{ - PlanInvalItem *newnode = makeNode(PlanInvalItem); - - COPY_SCALAR_FIELD(cacheId); - COPY_SCALAR_FIELD(hashValue); - - return newnode; -} - -/* **************************************************************** - * primnodes.h copy functions - * **************************************************************** + * Support functions for nodes with custom_copy_equal attribute */ -/* - * _copyAlias - */ -static Alias * -_copyAlias(const Alias *from) -{ - Alias *newnode = makeNode(Alias); - - COPY_STRING_FIELD(aliasname); - COPY_NODE_FIELD(colnames); - - return newnode; -} - -/* - * _copyRangeVar - */ -static RangeVar * -_copyRangeVar(const RangeVar *from) -{ - RangeVar *newnode = makeNode(RangeVar); - - COPY_STRING_FIELD(catalogname); - COPY_STRING_FIELD(schemaname); - COPY_STRING_FIELD(relname); - COPY_SCALAR_FIELD(inh); - COPY_SCALAR_FIELD(relpersistence); - COPY_NODE_FIELD(alias); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyTableFunc - */ -static TableFunc * -_copyTableFunc(const TableFunc *from) -{ - TableFunc *newnode = makeNode(TableFunc); - - COPY_SCALAR_FIELD(functype); - COPY_NODE_FIELD(ns_uris); - COPY_NODE_FIELD(ns_names); - COPY_NODE_FIELD(docexpr); - COPY_NODE_FIELD(rowexpr); - COPY_NODE_FIELD(colnames); - COPY_NODE_FIELD(coltypes); - COPY_NODE_FIELD(coltypmods); - COPY_NODE_FIELD(colcollations); - COPY_NODE_FIELD(colexprs); - COPY_NODE_FIELD(coldefexprs); - COPY_NODE_FIELD(colvalexprs); - COPY_BITMAPSET_FIELD(notnulls); - COPY_NODE_FIELD(plan); - COPY_SCALAR_FIELD(ordinalitycol); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyIntoClause - */ -static IntoClause * -_copyIntoClause(const IntoClause *from) -{ - IntoClause *newnode = makeNode(IntoClause); - - COPY_NODE_FIELD(rel); - COPY_NODE_FIELD(colNames); - COPY_STRING_FIELD(accessMethod); - COPY_NODE_FIELD(options); - COPY_SCALAR_FIELD(onCommit); - COPY_STRING_FIELD(tableSpaceName); - COPY_NODE_FIELD(viewQuery); - COPY_SCALAR_FIELD(skipData); - - return newnode; -} - -/* - * We don't need a _copyExpr because Expr is an abstract supertype which - * should never actually get instantiated. Also, since it has no common - * fields except NodeTag, there's no need for a helper routine to factor - * out copying the common fields... - */ - -/* - * _copyVar - */ -static Var * -_copyVar(const Var *from) -{ - Var *newnode = makeNode(Var); - - COPY_SCALAR_FIELD(varno); - COPY_SCALAR_FIELD(varattno); - COPY_SCALAR_FIELD(vartype); - COPY_SCALAR_FIELD(vartypmod); - COPY_SCALAR_FIELD(varcollid); - COPY_SCALAR_FIELD(varlevelsup); - COPY_SCALAR_FIELD(varnosyn); - COPY_SCALAR_FIELD(varattnosyn); - COPY_LOCATION_FIELD(location); - - return newnode; -} -#endif /* OBSOLETE */ - -/* - * _copyConst - */ static Const * _copyConst(const Const *from) { @@ -1470,1753 +104,6 @@ _copyConst(const Const *from) return newnode; } -#ifdef OBSOLETE -/* - * _copyParam - */ -static Param * -_copyParam(const Param *from) -{ - Param *newnode = makeNode(Param); - - COPY_SCALAR_FIELD(paramkind); - COPY_SCALAR_FIELD(paramid); - COPY_SCALAR_FIELD(paramtype); - COPY_SCALAR_FIELD(paramtypmod); - COPY_SCALAR_FIELD(paramcollid); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyAggref - */ -static Aggref * -_copyAggref(const Aggref *from) -{ - Aggref *newnode = makeNode(Aggref); - - COPY_SCALAR_FIELD(aggfnoid); - COPY_SCALAR_FIELD(aggtype); - COPY_SCALAR_FIELD(aggcollid); - COPY_SCALAR_FIELD(inputcollid); - COPY_SCALAR_FIELD(aggtranstype); - COPY_NODE_FIELD(aggargtypes); - COPY_NODE_FIELD(aggdirectargs); - COPY_NODE_FIELD(args); - COPY_NODE_FIELD(aggorder); - COPY_NODE_FIELD(aggdistinct); - COPY_NODE_FIELD(aggfilter); - COPY_SCALAR_FIELD(aggstar); - COPY_SCALAR_FIELD(aggvariadic); - COPY_SCALAR_FIELD(aggkind); - COPY_SCALAR_FIELD(agglevelsup); - COPY_SCALAR_FIELD(aggsplit); - COPY_SCALAR_FIELD(aggno); - COPY_SCALAR_FIELD(aggtransno); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyGroupingFunc - */ -static GroupingFunc * -_copyGroupingFunc(const GroupingFunc *from) -{ - GroupingFunc *newnode = makeNode(GroupingFunc); - - COPY_NODE_FIELD(args); - COPY_NODE_FIELD(refs); - COPY_NODE_FIELD(cols); - COPY_SCALAR_FIELD(agglevelsup); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyWindowFunc - */ -static WindowFunc * -_copyWindowFunc(const WindowFunc *from) -{ - WindowFunc *newnode = makeNode(WindowFunc); - - COPY_SCALAR_FIELD(winfnoid); - COPY_SCALAR_FIELD(wintype); - COPY_SCALAR_FIELD(wincollid); - COPY_SCALAR_FIELD(inputcollid); - COPY_NODE_FIELD(args); - COPY_NODE_FIELD(aggfilter); - COPY_SCALAR_FIELD(winref); - COPY_SCALAR_FIELD(winstar); - COPY_SCALAR_FIELD(winagg); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copySubscriptingRef - */ -static SubscriptingRef * -_copySubscriptingRef(const SubscriptingRef *from) -{ - SubscriptingRef *newnode = makeNode(SubscriptingRef); - - COPY_SCALAR_FIELD(refcontainertype); - COPY_SCALAR_FIELD(refelemtype); - COPY_SCALAR_FIELD(refrestype); - COPY_SCALAR_FIELD(reftypmod); - COPY_SCALAR_FIELD(refcollid); - COPY_NODE_FIELD(refupperindexpr); - COPY_NODE_FIELD(reflowerindexpr); - COPY_NODE_FIELD(refexpr); - COPY_NODE_FIELD(refassgnexpr); - - return newnode; -} - -/* - * _copyFuncExpr - */ -static FuncExpr * -_copyFuncExpr(const FuncExpr *from) -{ - FuncExpr *newnode = makeNode(FuncExpr); - - COPY_SCALAR_FIELD(funcid); - COPY_SCALAR_FIELD(funcresulttype); - COPY_SCALAR_FIELD(funcretset); - COPY_SCALAR_FIELD(funcvariadic); - COPY_SCALAR_FIELD(funcformat); - COPY_SCALAR_FIELD(funccollid); - COPY_SCALAR_FIELD(inputcollid); - COPY_NODE_FIELD(args); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyNamedArgExpr * - */ -static NamedArgExpr * -_copyNamedArgExpr(const NamedArgExpr *from) -{ - NamedArgExpr *newnode = makeNode(NamedArgExpr); - - COPY_NODE_FIELD(arg); - COPY_STRING_FIELD(name); - COPY_SCALAR_FIELD(argnumber); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyOpExpr - */ -static OpExpr * -_copyOpExpr(const OpExpr *from) -{ - OpExpr *newnode = makeNode(OpExpr); - - COPY_SCALAR_FIELD(opno); - COPY_SCALAR_FIELD(opfuncid); - COPY_SCALAR_FIELD(opresulttype); - COPY_SCALAR_FIELD(opretset); - COPY_SCALAR_FIELD(opcollid); - COPY_SCALAR_FIELD(inputcollid); - COPY_NODE_FIELD(args); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyDistinctExpr (same as OpExpr) - */ -static DistinctExpr * -_copyDistinctExpr(const DistinctExpr *from) -{ - DistinctExpr *newnode = makeNode(DistinctExpr); - - COPY_SCALAR_FIELD(opno); - COPY_SCALAR_FIELD(opfuncid); - COPY_SCALAR_FIELD(opresulttype); - COPY_SCALAR_FIELD(opretset); - COPY_SCALAR_FIELD(opcollid); - COPY_SCALAR_FIELD(inputcollid); - COPY_NODE_FIELD(args); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyNullIfExpr (same as OpExpr) - */ -static NullIfExpr * -_copyNullIfExpr(const NullIfExpr *from) -{ - NullIfExpr *newnode = makeNode(NullIfExpr); - - COPY_SCALAR_FIELD(opno); - COPY_SCALAR_FIELD(opfuncid); - COPY_SCALAR_FIELD(opresulttype); - COPY_SCALAR_FIELD(opretset); - COPY_SCALAR_FIELD(opcollid); - COPY_SCALAR_FIELD(inputcollid); - COPY_NODE_FIELD(args); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyScalarArrayOpExpr - */ -static ScalarArrayOpExpr * -_copyScalarArrayOpExpr(const ScalarArrayOpExpr *from) -{ - ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr); - - COPY_SCALAR_FIELD(opno); - COPY_SCALAR_FIELD(opfuncid); - COPY_SCALAR_FIELD(hashfuncid); - COPY_SCALAR_FIELD(negfuncid); - COPY_SCALAR_FIELD(useOr); - COPY_SCALAR_FIELD(inputcollid); - COPY_NODE_FIELD(args); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyBoolExpr - */ -static BoolExpr * -_copyBoolExpr(const BoolExpr *from) -{ - BoolExpr *newnode = makeNode(BoolExpr); - - COPY_SCALAR_FIELD(boolop); - COPY_NODE_FIELD(args); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copySubLink - */ -static SubLink * -_copySubLink(const SubLink *from) -{ - SubLink *newnode = makeNode(SubLink); - - COPY_SCALAR_FIELD(subLinkType); - COPY_SCALAR_FIELD(subLinkId); - COPY_NODE_FIELD(testexpr); - COPY_NODE_FIELD(operName); - COPY_NODE_FIELD(subselect); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copySubPlan - */ -static SubPlan * -_copySubPlan(const SubPlan *from) -{ - SubPlan *newnode = makeNode(SubPlan); - - COPY_SCALAR_FIELD(subLinkType); - COPY_NODE_FIELD(testexpr); - COPY_NODE_FIELD(paramIds); - COPY_SCALAR_FIELD(plan_id); - COPY_STRING_FIELD(plan_name); - COPY_SCALAR_FIELD(firstColType); - COPY_SCALAR_FIELD(firstColTypmod); - COPY_SCALAR_FIELD(firstColCollation); - COPY_SCALAR_FIELD(useHashTable); - COPY_SCALAR_FIELD(unknownEqFalse); - COPY_SCALAR_FIELD(parallel_safe); - COPY_NODE_FIELD(setParam); - COPY_NODE_FIELD(parParam); - COPY_NODE_FIELD(args); - COPY_SCALAR_FIELD(startup_cost); - COPY_SCALAR_FIELD(per_call_cost); - - return newnode; -} - -/* - * _copyAlternativeSubPlan - */ -static AlternativeSubPlan * -_copyAlternativeSubPlan(const AlternativeSubPlan *from) -{ - AlternativeSubPlan *newnode = makeNode(AlternativeSubPlan); - - COPY_NODE_FIELD(subplans); - - return newnode; -} - -/* - * _copyFieldSelect - */ -static FieldSelect * -_copyFieldSelect(const FieldSelect *from) -{ - FieldSelect *newnode = makeNode(FieldSelect); - - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(fieldnum); - COPY_SCALAR_FIELD(resulttype); - COPY_SCALAR_FIELD(resulttypmod); - COPY_SCALAR_FIELD(resultcollid); - - return newnode; -} - -/* - * _copyFieldStore - */ -static FieldStore * -_copyFieldStore(const FieldStore *from) -{ - FieldStore *newnode = makeNode(FieldStore); - - COPY_NODE_FIELD(arg); - COPY_NODE_FIELD(newvals); - COPY_NODE_FIELD(fieldnums); - COPY_SCALAR_FIELD(resulttype); - - return newnode; -} - -/* - * _copyRelabelType - */ -static RelabelType * -_copyRelabelType(const RelabelType *from) -{ - RelabelType *newnode = makeNode(RelabelType); - - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(resulttype); - COPY_SCALAR_FIELD(resulttypmod); - COPY_SCALAR_FIELD(resultcollid); - COPY_SCALAR_FIELD(relabelformat); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyCoerceViaIO - */ -static CoerceViaIO * -_copyCoerceViaIO(const CoerceViaIO *from) -{ - CoerceViaIO *newnode = makeNode(CoerceViaIO); - - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(resulttype); - COPY_SCALAR_FIELD(resultcollid); - COPY_SCALAR_FIELD(coerceformat); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyArrayCoerceExpr - */ -static ArrayCoerceExpr * -_copyArrayCoerceExpr(const ArrayCoerceExpr *from) -{ - ArrayCoerceExpr *newnode = makeNode(ArrayCoerceExpr); - - COPY_NODE_FIELD(arg); - COPY_NODE_FIELD(elemexpr); - COPY_SCALAR_FIELD(resulttype); - COPY_SCALAR_FIELD(resulttypmod); - COPY_SCALAR_FIELD(resultcollid); - COPY_SCALAR_FIELD(coerceformat); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyConvertRowtypeExpr - */ -static ConvertRowtypeExpr * -_copyConvertRowtypeExpr(const ConvertRowtypeExpr *from) -{ - ConvertRowtypeExpr *newnode = makeNode(ConvertRowtypeExpr); - - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(resulttype); - COPY_SCALAR_FIELD(convertformat); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyCollateExpr - */ -static CollateExpr * -_copyCollateExpr(const CollateExpr *from) -{ - CollateExpr *newnode = makeNode(CollateExpr); - - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(collOid); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyCaseExpr - */ -static CaseExpr * -_copyCaseExpr(const CaseExpr *from) -{ - CaseExpr *newnode = makeNode(CaseExpr); - - COPY_SCALAR_FIELD(casetype); - COPY_SCALAR_FIELD(casecollid); - COPY_NODE_FIELD(arg); - COPY_NODE_FIELD(args); - COPY_NODE_FIELD(defresult); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyCaseWhen - */ -static CaseWhen * -_copyCaseWhen(const CaseWhen *from) -{ - CaseWhen *newnode = makeNode(CaseWhen); - - COPY_NODE_FIELD(expr); - COPY_NODE_FIELD(result); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyCaseTestExpr - */ -static CaseTestExpr * -_copyCaseTestExpr(const CaseTestExpr *from) -{ - CaseTestExpr *newnode = makeNode(CaseTestExpr); - - COPY_SCALAR_FIELD(typeId); - COPY_SCALAR_FIELD(typeMod); - COPY_SCALAR_FIELD(collation); - - return newnode; -} - -/* - * _copyArrayExpr - */ -static ArrayExpr * -_copyArrayExpr(const ArrayExpr *from) -{ - ArrayExpr *newnode = makeNode(ArrayExpr); - - COPY_SCALAR_FIELD(array_typeid); - COPY_SCALAR_FIELD(array_collid); - COPY_SCALAR_FIELD(element_typeid); - COPY_NODE_FIELD(elements); - COPY_SCALAR_FIELD(multidims); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyRowExpr - */ -static RowExpr * -_copyRowExpr(const RowExpr *from) -{ - RowExpr *newnode = makeNode(RowExpr); - - COPY_NODE_FIELD(args); - COPY_SCALAR_FIELD(row_typeid); - COPY_SCALAR_FIELD(row_format); - COPY_NODE_FIELD(colnames); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyRowCompareExpr - */ -static RowCompareExpr * -_copyRowCompareExpr(const RowCompareExpr *from) -{ - RowCompareExpr *newnode = makeNode(RowCompareExpr); - - COPY_SCALAR_FIELD(rctype); - COPY_NODE_FIELD(opnos); - COPY_NODE_FIELD(opfamilies); - COPY_NODE_FIELD(inputcollids); - COPY_NODE_FIELD(largs); - COPY_NODE_FIELD(rargs); - - return newnode; -} - -/* - * _copyCoalesceExpr - */ -static CoalesceExpr * -_copyCoalesceExpr(const CoalesceExpr *from) -{ - CoalesceExpr *newnode = makeNode(CoalesceExpr); - - COPY_SCALAR_FIELD(coalescetype); - COPY_SCALAR_FIELD(coalescecollid); - COPY_NODE_FIELD(args); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyMinMaxExpr - */ -static MinMaxExpr * -_copyMinMaxExpr(const MinMaxExpr *from) -{ - MinMaxExpr *newnode = makeNode(MinMaxExpr); - - COPY_SCALAR_FIELD(minmaxtype); - COPY_SCALAR_FIELD(minmaxcollid); - COPY_SCALAR_FIELD(inputcollid); - COPY_SCALAR_FIELD(op); - COPY_NODE_FIELD(args); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copySQLValueFunction - */ -static SQLValueFunction * -_copySQLValueFunction(const SQLValueFunction *from) -{ - SQLValueFunction *newnode = makeNode(SQLValueFunction); - - COPY_SCALAR_FIELD(op); - COPY_SCALAR_FIELD(type); - COPY_SCALAR_FIELD(typmod); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyXmlExpr - */ -static XmlExpr * -_copyXmlExpr(const XmlExpr *from) -{ - XmlExpr *newnode = makeNode(XmlExpr); - - COPY_SCALAR_FIELD(op); - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(named_args); - COPY_NODE_FIELD(arg_names); - COPY_NODE_FIELD(args); - COPY_SCALAR_FIELD(xmloption); - COPY_SCALAR_FIELD(type); - COPY_SCALAR_FIELD(typmod); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyNullTest - */ -static NullTest * -_copyNullTest(const NullTest *from) -{ - NullTest *newnode = makeNode(NullTest); - - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(nulltesttype); - COPY_SCALAR_FIELD(argisrow); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyBooleanTest - */ -static BooleanTest * -_copyBooleanTest(const BooleanTest *from) -{ - BooleanTest *newnode = makeNode(BooleanTest); - - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(booltesttype); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyCoerceToDomain - */ -static CoerceToDomain * -_copyCoerceToDomain(const CoerceToDomain *from) -{ - CoerceToDomain *newnode = makeNode(CoerceToDomain); - - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(resulttype); - COPY_SCALAR_FIELD(resulttypmod); - COPY_SCALAR_FIELD(resultcollid); - COPY_SCALAR_FIELD(coercionformat); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyCoerceToDomainValue - */ -static CoerceToDomainValue * -_copyCoerceToDomainValue(const CoerceToDomainValue *from) -{ - CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue); - - COPY_SCALAR_FIELD(typeId); - COPY_SCALAR_FIELD(typeMod); - COPY_SCALAR_FIELD(collation); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copySetToDefault - */ -static SetToDefault * -_copySetToDefault(const SetToDefault *from) -{ - SetToDefault *newnode = makeNode(SetToDefault); - - COPY_SCALAR_FIELD(typeId); - COPY_SCALAR_FIELD(typeMod); - COPY_SCALAR_FIELD(collation); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyCurrentOfExpr - */ -static CurrentOfExpr * -_copyCurrentOfExpr(const CurrentOfExpr *from) -{ - CurrentOfExpr *newnode = makeNode(CurrentOfExpr); - - COPY_SCALAR_FIELD(cvarno); - COPY_STRING_FIELD(cursor_name); - COPY_SCALAR_FIELD(cursor_param); - - return newnode; -} - - /* - * _copyNextValueExpr - */ -static NextValueExpr * -_copyNextValueExpr(const NextValueExpr *from) -{ - NextValueExpr *newnode = makeNode(NextValueExpr); - - COPY_SCALAR_FIELD(seqid); - COPY_SCALAR_FIELD(typeId); - - return newnode; -} - -/* - * _copyInferenceElem - */ -static InferenceElem * -_copyInferenceElem(const InferenceElem *from) -{ - InferenceElem *newnode = makeNode(InferenceElem); - - COPY_NODE_FIELD(expr); - COPY_SCALAR_FIELD(infercollid); - COPY_SCALAR_FIELD(inferopclass); - - return newnode; -} - -/* - * _copyTargetEntry - */ -static TargetEntry * -_copyTargetEntry(const TargetEntry *from) -{ - TargetEntry *newnode = makeNode(TargetEntry); - - COPY_NODE_FIELD(expr); - COPY_SCALAR_FIELD(resno); - COPY_STRING_FIELD(resname); - COPY_SCALAR_FIELD(ressortgroupref); - COPY_SCALAR_FIELD(resorigtbl); - COPY_SCALAR_FIELD(resorigcol); - COPY_SCALAR_FIELD(resjunk); - - return newnode; -} - -/* - * _copyRangeTblRef - */ -static RangeTblRef * -_copyRangeTblRef(const RangeTblRef *from) -{ - RangeTblRef *newnode = makeNode(RangeTblRef); - - COPY_SCALAR_FIELD(rtindex); - - return newnode; -} - -/* - * _copyJoinExpr - */ -static JoinExpr * -_copyJoinExpr(const JoinExpr *from) -{ - JoinExpr *newnode = makeNode(JoinExpr); - - COPY_SCALAR_FIELD(jointype); - COPY_SCALAR_FIELD(isNatural); - COPY_NODE_FIELD(larg); - COPY_NODE_FIELD(rarg); - COPY_NODE_FIELD(usingClause); - COPY_NODE_FIELD(join_using_alias); - COPY_NODE_FIELD(quals); - COPY_NODE_FIELD(alias); - COPY_SCALAR_FIELD(rtindex); - - return newnode; -} - -/* - * _copyFromExpr - */ -static FromExpr * -_copyFromExpr(const FromExpr *from) -{ - FromExpr *newnode = makeNode(FromExpr); - - COPY_NODE_FIELD(fromlist); - COPY_NODE_FIELD(quals); - - return newnode; -} - -/* - * _copyOnConflictExpr - */ -static OnConflictExpr * -_copyOnConflictExpr(const OnConflictExpr *from) -{ - OnConflictExpr *newnode = makeNode(OnConflictExpr); - - COPY_SCALAR_FIELD(action); - COPY_NODE_FIELD(arbiterElems); - COPY_NODE_FIELD(arbiterWhere); - COPY_SCALAR_FIELD(constraint); - COPY_NODE_FIELD(onConflictSet); - COPY_NODE_FIELD(onConflictWhere); - COPY_SCALAR_FIELD(exclRelIndex); - COPY_NODE_FIELD(exclRelTlist); - - return newnode; -} - - -/* - * _copyJsonFormat - */ -static JsonFormat * -_copyJsonFormat(const JsonFormat *from) -{ - JsonFormat *newnode = makeNode(JsonFormat); - - COPY_SCALAR_FIELD(format_type); - COPY_SCALAR_FIELD(encoding); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonReturning - */ -static JsonReturning * -_copyJsonReturning(const JsonReturning *from) -{ - JsonReturning *newnode = makeNode(JsonReturning); - - COPY_NODE_FIELD(format); - COPY_SCALAR_FIELD(typid); - COPY_SCALAR_FIELD(typmod); - - return newnode; -} - -/* - * _copyJsonValueExpr - */ -static JsonValueExpr * -_copyJsonValueExpr(const JsonValueExpr *from) -{ - JsonValueExpr *newnode = makeNode(JsonValueExpr); - - COPY_NODE_FIELD(raw_expr); - COPY_NODE_FIELD(formatted_expr); - COPY_NODE_FIELD(format); - - return newnode; -} - -/* - * _copyJsonParseExpr - */ -static JsonParseExpr * -_copyJsonParseExpr(const JsonParseExpr *from) -{ - JsonParseExpr *newnode = makeNode(JsonParseExpr); - - COPY_NODE_FIELD(expr); - COPY_NODE_FIELD(output); - COPY_SCALAR_FIELD(unique_keys); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonScalarExpr - */ -static JsonScalarExpr * -_copyJsonScalarExpr(const JsonScalarExpr *from) -{ - JsonScalarExpr *newnode = makeNode(JsonScalarExpr); - - COPY_NODE_FIELD(expr); - COPY_NODE_FIELD(output); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonSerializeExpr - */ -static JsonSerializeExpr * -_copyJsonSerializeExpr(const JsonSerializeExpr *from) -{ - JsonSerializeExpr *newnode = makeNode(JsonSerializeExpr); - - COPY_NODE_FIELD(expr); - COPY_NODE_FIELD(output); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonConstructorExpr - */ -static JsonConstructorExpr * -_copyJsonConstructorExpr(const JsonConstructorExpr *from) -{ - JsonConstructorExpr *newnode = makeNode(JsonConstructorExpr); - - COPY_SCALAR_FIELD(type); - COPY_NODE_FIELD(args); - COPY_NODE_FIELD(func); - COPY_NODE_FIELD(coercion); - COPY_NODE_FIELD(returning); - COPY_SCALAR_FIELD(absent_on_null); - COPY_SCALAR_FIELD(unique); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonKeyValue - */ -static JsonKeyValue * -_copyJsonKeyValue(const JsonKeyValue *from) -{ - JsonKeyValue *newnode = makeNode(JsonKeyValue); - - COPY_NODE_FIELD(key); - COPY_NODE_FIELD(value); - - return newnode; -} - -/* - * _copyJsonObjectConstructor - */ -static JsonObjectConstructor * -_copyJsonObjectConstructor(const JsonObjectConstructor *from) -{ - JsonObjectConstructor *newnode = makeNode(JsonObjectConstructor); - - COPY_NODE_FIELD(exprs); - COPY_NODE_FIELD(output); - COPY_SCALAR_FIELD(absent_on_null); - COPY_SCALAR_FIELD(unique); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonAggConstructor - */ -static JsonAggConstructor * -_copyJsonAggConstructor(const JsonAggConstructor *from) -{ - JsonAggConstructor *newnode = makeNode(JsonAggConstructor); - - COPY_NODE_FIELD(output); - COPY_NODE_FIELD(agg_filter); - COPY_NODE_FIELD(agg_order); - COPY_NODE_FIELD(over); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonObjectAgg - */ -static JsonObjectAgg * -_copyJsonObjectAgg(const JsonObjectAgg *from) -{ - JsonObjectAgg *newnode = makeNode(JsonObjectAgg); - - COPY_NODE_FIELD(constructor); - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(absent_on_null); - COPY_SCALAR_FIELD(unique); - - return newnode; -} - -/* - * _copyJsonOutput - */ -static JsonOutput * -_copyJsonOutput(const JsonOutput *from) -{ - JsonOutput *newnode = makeNode(JsonOutput); - - COPY_NODE_FIELD(typeName); - COPY_NODE_FIELD(returning); - - return newnode; -} - -/* - * _copyJsonArrayConstructor - */ -static JsonArrayConstructor * -_copyJsonArrayConstructor(const JsonArrayConstructor *from) -{ - JsonArrayConstructor *newnode = makeNode(JsonArrayConstructor); - - COPY_NODE_FIELD(exprs); - COPY_NODE_FIELD(output); - COPY_SCALAR_FIELD(absent_on_null); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonArrayAgg - */ -static JsonArrayAgg * -_copyJsonArrayAgg(const JsonArrayAgg *from) -{ - JsonArrayAgg *newnode = makeNode(JsonArrayAgg); - - COPY_NODE_FIELD(constructor); - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(absent_on_null); - - return newnode; -} - -/* - * _copyJsonArrayQueryConstructor - */ -static JsonArrayQueryConstructor * -_copyJsonArrayQueryConstructor(const JsonArrayQueryConstructor *from) -{ - JsonArrayQueryConstructor *newnode = makeNode(JsonArrayQueryConstructor); - - COPY_NODE_FIELD(query); - COPY_NODE_FIELD(output); - COPY_NODE_FIELD(format); - COPY_SCALAR_FIELD(absent_on_null); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonExpr - */ -static JsonExpr * -_copyJsonExpr(const JsonExpr *from) -{ - JsonExpr *newnode = makeNode(JsonExpr); - - COPY_SCALAR_FIELD(op); - COPY_NODE_FIELD(formatted_expr); - COPY_NODE_FIELD(result_coercion); - COPY_NODE_FIELD(format); - COPY_NODE_FIELD(path_spec); - COPY_NODE_FIELD(passing_names); - COPY_NODE_FIELD(passing_values); - COPY_NODE_FIELD(returning); - COPY_NODE_FIELD(on_empty); - COPY_NODE_FIELD(on_error); - COPY_NODE_FIELD(coercions); - COPY_SCALAR_FIELD(wrapper); - COPY_SCALAR_FIELD(omit_quotes); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonCoercion - */ -static JsonCoercion * -_copyJsonCoercion(const JsonCoercion *from) -{ - JsonCoercion *newnode = makeNode(JsonCoercion); - - COPY_NODE_FIELD(expr); - COPY_SCALAR_FIELD(via_populate); - COPY_SCALAR_FIELD(via_io); - COPY_SCALAR_FIELD(collation); - - return newnode; -} - -/* - * _copyJsonItemCoercions - */ -static JsonItemCoercions * -_copyJsonItemCoercions(const JsonItemCoercions *from) -{ - JsonItemCoercions *newnode = makeNode(JsonItemCoercions); - - COPY_NODE_FIELD(null); - COPY_NODE_FIELD(string); - COPY_NODE_FIELD(numeric); - COPY_NODE_FIELD(boolean); - COPY_NODE_FIELD(date); - COPY_NODE_FIELD(time); - COPY_NODE_FIELD(timetz); - COPY_NODE_FIELD(timestamp); - COPY_NODE_FIELD(timestamptz); - COPY_NODE_FIELD(composite); - - return newnode; -} - -/* - * _copyJsonFuncExpr - */ -static JsonFuncExpr * -_copyJsonFuncExpr(const JsonFuncExpr *from) -{ - JsonFuncExpr *newnode = makeNode(JsonFuncExpr); - - COPY_SCALAR_FIELD(op); - COPY_NODE_FIELD(common); - COPY_NODE_FIELD(output); - COPY_NODE_FIELD(on_empty); - COPY_NODE_FIELD(on_error); - COPY_SCALAR_FIELD(wrapper); - COPY_SCALAR_FIELD(omit_quotes); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonIsPredicate - */ -static JsonIsPredicate * -_copyJsonIsPredicate(const JsonIsPredicate *from) -{ - JsonIsPredicate *newnode = makeNode(JsonIsPredicate); - - COPY_NODE_FIELD(expr); - COPY_NODE_FIELD(format); - COPY_SCALAR_FIELD(item_type); - COPY_SCALAR_FIELD(unique_keys); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonBehavior - */ -static JsonBehavior * -_copyJsonBehavior(const JsonBehavior *from) -{ - JsonBehavior *newnode = makeNode(JsonBehavior); - - COPY_SCALAR_FIELD(btype); - COPY_NODE_FIELD(default_expr); - - return newnode; -} - -/* - * _copyJsonCommon - */ -static JsonCommon * -_copyJsonCommon(const JsonCommon *from) -{ - JsonCommon *newnode = makeNode(JsonCommon); - - COPY_NODE_FIELD(expr); - COPY_NODE_FIELD(pathspec); - COPY_STRING_FIELD(pathname); - COPY_NODE_FIELD(passing); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonArgument - */ -static JsonArgument * -_copyJsonArgument(const JsonArgument *from) -{ - JsonArgument *newnode = makeNode(JsonArgument); - - COPY_NODE_FIELD(val); - COPY_STRING_FIELD(name); - - return newnode; -} - -/* - * _copyJsonTable - */ -static JsonTable * -_copyJsonTable(const JsonTable *from) -{ - JsonTable *newnode = makeNode(JsonTable); - - COPY_NODE_FIELD(common); - COPY_NODE_FIELD(columns); - COPY_NODE_FIELD(plan); - COPY_NODE_FIELD(on_error); - COPY_NODE_FIELD(alias); - COPY_SCALAR_FIELD(lateral); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonTableColumn - */ -static JsonTableColumn * -_copyJsonTableColumn(const JsonTableColumn *from) -{ - JsonTableColumn *newnode = makeNode(JsonTableColumn); - - COPY_SCALAR_FIELD(coltype); - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(typeName); - COPY_STRING_FIELD(pathspec); - COPY_STRING_FIELD(pathname); - COPY_NODE_FIELD(format); - COPY_SCALAR_FIELD(wrapper); - COPY_SCALAR_FIELD(omit_quotes); - COPY_NODE_FIELD(columns); - COPY_NODE_FIELD(on_empty); - COPY_NODE_FIELD(on_error); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonTablePlan - */ -static JsonTablePlan * -_copyJsonTablePlan(const JsonTablePlan *from) -{ - JsonTablePlan *newnode = makeNode(JsonTablePlan); - - COPY_SCALAR_FIELD(plan_type); - COPY_SCALAR_FIELD(join_type); - COPY_NODE_FIELD(plan1); - COPY_NODE_FIELD(plan2); - COPY_STRING_FIELD(pathname); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -/* - * _copyJsonTableParent - */ -static JsonTableParent * -_copyJsonTableParent(const JsonTableParent *from) -{ - JsonTableParent *newnode = makeNode(JsonTableParent); - - COPY_NODE_FIELD(path); - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(child); - COPY_SCALAR_FIELD(outerJoin); - COPY_SCALAR_FIELD(colMin); - COPY_SCALAR_FIELD(colMax); - COPY_SCALAR_FIELD(errorOnError); - - return newnode; -} - -/* - * _copyJsonTableSibling - */ -static JsonTableSibling * -_copyJsonTableSibling(const JsonTableSibling *from) -{ - JsonTableSibling *newnode = makeNode(JsonTableSibling); - - COPY_NODE_FIELD(larg); - COPY_NODE_FIELD(rarg); - COPY_SCALAR_FIELD(cross); - - return newnode; -} - -/* **************************************************************** - * pathnodes.h copy functions - * - * We don't support copying RelOptInfo, IndexOptInfo, or Path nodes. - * There are some subsidiary structs that are useful to copy, though. - * **************************************************************** - */ - -/* - * _copyPathKey - */ -static PathKey * -_copyPathKey(const PathKey *from) -{ - PathKey *newnode = makeNode(PathKey); - - /* EquivalenceClasses are never moved, so just shallow-copy the pointer */ - COPY_SCALAR_FIELD(pk_eclass); - COPY_SCALAR_FIELD(pk_opfamily); - COPY_SCALAR_FIELD(pk_strategy); - COPY_SCALAR_FIELD(pk_nulls_first); - - return newnode; -} - -/* - * _copyRestrictInfo - */ -static RestrictInfo * -_copyRestrictInfo(const RestrictInfo *from) -{ - RestrictInfo *newnode = makeNode(RestrictInfo); - - COPY_NODE_FIELD(clause); - COPY_SCALAR_FIELD(is_pushed_down); - COPY_SCALAR_FIELD(outerjoin_delayed); - COPY_SCALAR_FIELD(can_join); - COPY_SCALAR_FIELD(pseudoconstant); - COPY_SCALAR_FIELD(leakproof); - COPY_SCALAR_FIELD(has_volatile); - COPY_SCALAR_FIELD(security_level); - COPY_BITMAPSET_FIELD(clause_relids); - COPY_BITMAPSET_FIELD(required_relids); - COPY_BITMAPSET_FIELD(outer_relids); - COPY_BITMAPSET_FIELD(nullable_relids); - COPY_BITMAPSET_FIELD(left_relids); - COPY_BITMAPSET_FIELD(right_relids); - COPY_NODE_FIELD(orclause); - /* EquivalenceClasses are never copied, so shallow-copy the pointers */ - COPY_SCALAR_FIELD(parent_ec); - COPY_SCALAR_FIELD(eval_cost); - COPY_SCALAR_FIELD(norm_selec); - COPY_SCALAR_FIELD(outer_selec); - COPY_NODE_FIELD(mergeopfamilies); - /* EquivalenceClasses are never copied, so shallow-copy the pointers */ - COPY_SCALAR_FIELD(left_ec); - COPY_SCALAR_FIELD(right_ec); - COPY_SCALAR_FIELD(left_em); - COPY_SCALAR_FIELD(right_em); - /* MergeScanSelCache isn't a Node, so hard to copy; just reset cache */ - newnode->scansel_cache = NIL; - COPY_SCALAR_FIELD(outer_is_left); - COPY_SCALAR_FIELD(hashjoinoperator); - COPY_SCALAR_FIELD(left_bucketsize); - COPY_SCALAR_FIELD(right_bucketsize); - COPY_SCALAR_FIELD(left_mcvfreq); - COPY_SCALAR_FIELD(right_mcvfreq); - COPY_SCALAR_FIELD(left_hasheqoperator); - COPY_SCALAR_FIELD(right_hasheqoperator); - - return newnode; -} - -/* - * _copyPlaceHolderVar - */ -static PlaceHolderVar * -_copyPlaceHolderVar(const PlaceHolderVar *from) -{ - PlaceHolderVar *newnode = makeNode(PlaceHolderVar); - - COPY_NODE_FIELD(phexpr); - COPY_BITMAPSET_FIELD(phrels); - COPY_SCALAR_FIELD(phid); - COPY_SCALAR_FIELD(phlevelsup); - - return newnode; -} - -/* - * _copySpecialJoinInfo - */ -static SpecialJoinInfo * -_copySpecialJoinInfo(const SpecialJoinInfo *from) -{ - SpecialJoinInfo *newnode = makeNode(SpecialJoinInfo); - - COPY_BITMAPSET_FIELD(min_lefthand); - COPY_BITMAPSET_FIELD(min_righthand); - COPY_BITMAPSET_FIELD(syn_lefthand); - COPY_BITMAPSET_FIELD(syn_righthand); - COPY_SCALAR_FIELD(jointype); - COPY_SCALAR_FIELD(lhs_strict); - COPY_SCALAR_FIELD(delay_upper_joins); - COPY_SCALAR_FIELD(semi_can_btree); - COPY_SCALAR_FIELD(semi_can_hash); - COPY_NODE_FIELD(semi_operators); - COPY_NODE_FIELD(semi_rhs_exprs); - - return newnode; -} - -/* - * _copyAppendRelInfo - */ -static AppendRelInfo * -_copyAppendRelInfo(const AppendRelInfo *from) -{ - AppendRelInfo *newnode = makeNode(AppendRelInfo); - - COPY_SCALAR_FIELD(parent_relid); - COPY_SCALAR_FIELD(child_relid); - COPY_SCALAR_FIELD(parent_reltype); - COPY_SCALAR_FIELD(child_reltype); - COPY_NODE_FIELD(translated_vars); - COPY_SCALAR_FIELD(num_child_cols); - COPY_POINTER_FIELD(parent_colnos, from->num_child_cols * sizeof(AttrNumber)); - COPY_SCALAR_FIELD(parent_reloid); - - return newnode; -} - -/* - * _copyPlaceHolderInfo - */ -static PlaceHolderInfo * -_copyPlaceHolderInfo(const PlaceHolderInfo *from) -{ - PlaceHolderInfo *newnode = makeNode(PlaceHolderInfo); - - COPY_SCALAR_FIELD(phid); - COPY_NODE_FIELD(ph_var); - COPY_BITMAPSET_FIELD(ph_eval_at); - COPY_BITMAPSET_FIELD(ph_lateral); - COPY_BITMAPSET_FIELD(ph_needed); - COPY_SCALAR_FIELD(ph_width); - - return newnode; -} - -/* **************************************************************** - * parsenodes.h copy functions - * **************************************************************** - */ - -static RangeTblEntry * -_copyRangeTblEntry(const RangeTblEntry *from) -{ - RangeTblEntry *newnode = makeNode(RangeTblEntry); - - COPY_SCALAR_FIELD(rtekind); - COPY_SCALAR_FIELD(relid); - COPY_SCALAR_FIELD(relkind); - COPY_SCALAR_FIELD(rellockmode); - COPY_NODE_FIELD(tablesample); - COPY_NODE_FIELD(subquery); - COPY_SCALAR_FIELD(security_barrier); - COPY_SCALAR_FIELD(jointype); - COPY_SCALAR_FIELD(joinmergedcols); - COPY_NODE_FIELD(joinaliasvars); - COPY_NODE_FIELD(joinleftcols); - COPY_NODE_FIELD(joinrightcols); - COPY_NODE_FIELD(join_using_alias); - COPY_NODE_FIELD(functions); - COPY_SCALAR_FIELD(funcordinality); - COPY_NODE_FIELD(tablefunc); - COPY_NODE_FIELD(values_lists); - COPY_STRING_FIELD(ctename); - COPY_SCALAR_FIELD(ctelevelsup); - COPY_SCALAR_FIELD(self_reference); - COPY_NODE_FIELD(coltypes); - COPY_NODE_FIELD(coltypmods); - COPY_NODE_FIELD(colcollations); - COPY_STRING_FIELD(enrname); - COPY_SCALAR_FIELD(enrtuples); - COPY_NODE_FIELD(alias); - COPY_NODE_FIELD(eref); - COPY_SCALAR_FIELD(lateral); - COPY_SCALAR_FIELD(inh); - COPY_SCALAR_FIELD(inFromCl); - COPY_SCALAR_FIELD(requiredPerms); - COPY_SCALAR_FIELD(checkAsUser); - COPY_BITMAPSET_FIELD(selectedCols); - COPY_BITMAPSET_FIELD(insertedCols); - COPY_BITMAPSET_FIELD(updatedCols); - COPY_BITMAPSET_FIELD(extraUpdatedCols); - COPY_NODE_FIELD(securityQuals); - - return newnode; -} - -static RangeTblFunction * -_copyRangeTblFunction(const RangeTblFunction *from) -{ - RangeTblFunction *newnode = makeNode(RangeTblFunction); - - COPY_NODE_FIELD(funcexpr); - COPY_SCALAR_FIELD(funccolcount); - COPY_NODE_FIELD(funccolnames); - COPY_NODE_FIELD(funccoltypes); - COPY_NODE_FIELD(funccoltypmods); - COPY_NODE_FIELD(funccolcollations); - COPY_BITMAPSET_FIELD(funcparams); - - return newnode; -} - -static TableSampleClause * -_copyTableSampleClause(const TableSampleClause *from) -{ - TableSampleClause *newnode = makeNode(TableSampleClause); - - COPY_SCALAR_FIELD(tsmhandler); - COPY_NODE_FIELD(args); - COPY_NODE_FIELD(repeatable); - - return newnode; -} - -static WithCheckOption * -_copyWithCheckOption(const WithCheckOption *from) -{ - WithCheckOption *newnode = makeNode(WithCheckOption); - - COPY_SCALAR_FIELD(kind); - COPY_STRING_FIELD(relname); - COPY_STRING_FIELD(polname); - COPY_NODE_FIELD(qual); - COPY_SCALAR_FIELD(cascaded); - - return newnode; -} - -static SortGroupClause * -_copySortGroupClause(const SortGroupClause *from) -{ - SortGroupClause *newnode = makeNode(SortGroupClause); - - COPY_SCALAR_FIELD(tleSortGroupRef); - COPY_SCALAR_FIELD(eqop); - COPY_SCALAR_FIELD(sortop); - COPY_SCALAR_FIELD(nulls_first); - COPY_SCALAR_FIELD(hashable); - - return newnode; -} - -static GroupingSet * -_copyGroupingSet(const GroupingSet *from) -{ - GroupingSet *newnode = makeNode(GroupingSet); - - COPY_SCALAR_FIELD(kind); - COPY_NODE_FIELD(content); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static WindowClause * -_copyWindowClause(const WindowClause *from) -{ - WindowClause *newnode = makeNode(WindowClause); - - COPY_STRING_FIELD(name); - COPY_STRING_FIELD(refname); - COPY_NODE_FIELD(partitionClause); - COPY_NODE_FIELD(orderClause); - COPY_SCALAR_FIELD(frameOptions); - COPY_NODE_FIELD(startOffset); - COPY_NODE_FIELD(endOffset); - COPY_NODE_FIELD(runCondition); - COPY_SCALAR_FIELD(startInRangeFunc); - COPY_SCALAR_FIELD(endInRangeFunc); - COPY_SCALAR_FIELD(inRangeColl); - COPY_SCALAR_FIELD(inRangeAsc); - COPY_SCALAR_FIELD(inRangeNullsFirst); - COPY_SCALAR_FIELD(winref); - COPY_SCALAR_FIELD(copiedOrder); - - return newnode; -} - -static RowMarkClause * -_copyRowMarkClause(const RowMarkClause *from) -{ - RowMarkClause *newnode = makeNode(RowMarkClause); - - COPY_SCALAR_FIELD(rti); - COPY_SCALAR_FIELD(strength); - COPY_SCALAR_FIELD(waitPolicy); - COPY_SCALAR_FIELD(pushedDown); - - return newnode; -} - -static WithClause * -_copyWithClause(const WithClause *from) -{ - WithClause *newnode = makeNode(WithClause); - - COPY_NODE_FIELD(ctes); - COPY_SCALAR_FIELD(recursive); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static InferClause * -_copyInferClause(const InferClause *from) -{ - InferClause *newnode = makeNode(InferClause); - - COPY_NODE_FIELD(indexElems); - COPY_NODE_FIELD(whereClause); - COPY_STRING_FIELD(conname); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static OnConflictClause * -_copyOnConflictClause(const OnConflictClause *from) -{ - OnConflictClause *newnode = makeNode(OnConflictClause); - - COPY_SCALAR_FIELD(action); - COPY_NODE_FIELD(infer); - COPY_NODE_FIELD(targetList); - COPY_NODE_FIELD(whereClause); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static CTESearchClause * -_copyCTESearchClause(const CTESearchClause *from) -{ - CTESearchClause *newnode = makeNode(CTESearchClause); - - COPY_NODE_FIELD(search_col_list); - COPY_SCALAR_FIELD(search_breadth_first); - COPY_STRING_FIELD(search_seq_column); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static CTECycleClause * -_copyCTECycleClause(const CTECycleClause *from) -{ - CTECycleClause *newnode = makeNode(CTECycleClause); - - COPY_NODE_FIELD(cycle_col_list); - COPY_STRING_FIELD(cycle_mark_column); - COPY_NODE_FIELD(cycle_mark_value); - COPY_NODE_FIELD(cycle_mark_default); - COPY_STRING_FIELD(cycle_path_column); - COPY_LOCATION_FIELD(location); - COPY_SCALAR_FIELD(cycle_mark_type); - COPY_SCALAR_FIELD(cycle_mark_typmod); - COPY_SCALAR_FIELD(cycle_mark_collation); - COPY_SCALAR_FIELD(cycle_mark_neop); - - return newnode; -} - -static CommonTableExpr * -_copyCommonTableExpr(const CommonTableExpr *from) -{ - CommonTableExpr *newnode = makeNode(CommonTableExpr); - - COPY_STRING_FIELD(ctename); - COPY_NODE_FIELD(aliascolnames); - COPY_SCALAR_FIELD(ctematerialized); - COPY_NODE_FIELD(ctequery); - COPY_NODE_FIELD(search_clause); - COPY_NODE_FIELD(cycle_clause); - COPY_LOCATION_FIELD(location); - COPY_SCALAR_FIELD(cterecursive); - COPY_SCALAR_FIELD(cterefcount); - COPY_NODE_FIELD(ctecolnames); - COPY_NODE_FIELD(ctecoltypes); - COPY_NODE_FIELD(ctecoltypmods); - COPY_NODE_FIELD(ctecolcollations); - - return newnode; -} - -static MergeWhenClause * -_copyMergeWhenClause(const MergeWhenClause *from) -{ - MergeWhenClause *newnode = makeNode(MergeWhenClause); - - COPY_SCALAR_FIELD(matched); - COPY_SCALAR_FIELD(commandType); - COPY_SCALAR_FIELD(override); - COPY_NODE_FIELD(condition); - COPY_NODE_FIELD(targetList); - COPY_NODE_FIELD(values); - return newnode; -} - -static MergeAction * -_copyMergeAction(const MergeAction *from) -{ - MergeAction *newnode = makeNode(MergeAction); - - COPY_SCALAR_FIELD(matched); - COPY_SCALAR_FIELD(commandType); - COPY_SCALAR_FIELD(override); - COPY_NODE_FIELD(qual); - COPY_NODE_FIELD(targetList); - COPY_NODE_FIELD(updateColnos); - - return newnode; -} - -static A_Expr * -_copyA_Expr(const A_Expr *from) -{ - A_Expr *newnode = makeNode(A_Expr); - - COPY_SCALAR_FIELD(kind); - COPY_NODE_FIELD(name); - COPY_NODE_FIELD(lexpr); - COPY_NODE_FIELD(rexpr); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static ColumnRef * -_copyColumnRef(const ColumnRef *from) -{ - ColumnRef *newnode = makeNode(ColumnRef); - - COPY_NODE_FIELD(fields); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static ParamRef * -_copyParamRef(const ParamRef *from) -{ - ParamRef *newnode = makeNode(ParamRef); - - COPY_SCALAR_FIELD(number); - COPY_LOCATION_FIELD(location); - - return newnode; -} -#endif /* OBSOLETE */ - static A_Const * _copyA_Const(const A_Const *from) { @@ -3256,2178 +143,6 @@ _copyA_Const(const A_Const *from) return newnode; } -#ifdef OBSOLETE -static FuncCall * -_copyFuncCall(const FuncCall *from) -{ - FuncCall *newnode = makeNode(FuncCall); - - COPY_NODE_FIELD(funcname); - COPY_NODE_FIELD(args); - COPY_NODE_FIELD(agg_order); - COPY_NODE_FIELD(agg_filter); - COPY_NODE_FIELD(over); - COPY_SCALAR_FIELD(agg_within_group); - COPY_SCALAR_FIELD(agg_star); - COPY_SCALAR_FIELD(agg_distinct); - COPY_SCALAR_FIELD(func_variadic); - COPY_SCALAR_FIELD(funcformat); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static A_Star * -_copyA_Star(const A_Star *from) -{ - A_Star *newnode = makeNode(A_Star); - - return newnode; -} - -static A_Indices * -_copyA_Indices(const A_Indices *from) -{ - A_Indices *newnode = makeNode(A_Indices); - - COPY_SCALAR_FIELD(is_slice); - COPY_NODE_FIELD(lidx); - COPY_NODE_FIELD(uidx); - - return newnode; -} - -static A_Indirection * -_copyA_Indirection(const A_Indirection *from) -{ - A_Indirection *newnode = makeNode(A_Indirection); - - COPY_NODE_FIELD(arg); - COPY_NODE_FIELD(indirection); - - return newnode; -} - -static A_ArrayExpr * -_copyA_ArrayExpr(const A_ArrayExpr *from) -{ - A_ArrayExpr *newnode = makeNode(A_ArrayExpr); - - COPY_NODE_FIELD(elements); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static ResTarget * -_copyResTarget(const ResTarget *from) -{ - ResTarget *newnode = makeNode(ResTarget); - - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(indirection); - COPY_NODE_FIELD(val); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static MultiAssignRef * -_copyMultiAssignRef(const MultiAssignRef *from) -{ - MultiAssignRef *newnode = makeNode(MultiAssignRef); - - COPY_NODE_FIELD(source); - COPY_SCALAR_FIELD(colno); - COPY_SCALAR_FIELD(ncolumns); - - return newnode; -} - -static TypeName * -_copyTypeName(const TypeName *from) -{ - TypeName *newnode = makeNode(TypeName); - - COPY_NODE_FIELD(names); - COPY_SCALAR_FIELD(typeOid); - COPY_SCALAR_FIELD(setof); - COPY_SCALAR_FIELD(pct_type); - COPY_NODE_FIELD(typmods); - COPY_SCALAR_FIELD(typemod); - COPY_NODE_FIELD(arrayBounds); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static SortBy * -_copySortBy(const SortBy *from) -{ - SortBy *newnode = makeNode(SortBy); - - COPY_NODE_FIELD(node); - COPY_SCALAR_FIELD(sortby_dir); - COPY_SCALAR_FIELD(sortby_nulls); - COPY_NODE_FIELD(useOp); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static WindowDef * -_copyWindowDef(const WindowDef *from) -{ - WindowDef *newnode = makeNode(WindowDef); - - COPY_STRING_FIELD(name); - COPY_STRING_FIELD(refname); - COPY_NODE_FIELD(partitionClause); - COPY_NODE_FIELD(orderClause); - COPY_SCALAR_FIELD(frameOptions); - COPY_NODE_FIELD(startOffset); - COPY_NODE_FIELD(endOffset); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static RangeSubselect * -_copyRangeSubselect(const RangeSubselect *from) -{ - RangeSubselect *newnode = makeNode(RangeSubselect); - - COPY_SCALAR_FIELD(lateral); - COPY_NODE_FIELD(subquery); - COPY_NODE_FIELD(alias); - - return newnode; -} - -static RangeFunction * -_copyRangeFunction(const RangeFunction *from) -{ - RangeFunction *newnode = makeNode(RangeFunction); - - COPY_SCALAR_FIELD(lateral); - COPY_SCALAR_FIELD(ordinality); - COPY_SCALAR_FIELD(is_rowsfrom); - COPY_NODE_FIELD(functions); - COPY_NODE_FIELD(alias); - COPY_NODE_FIELD(coldeflist); - - return newnode; -} - -static RangeTableSample * -_copyRangeTableSample(const RangeTableSample *from) -{ - RangeTableSample *newnode = makeNode(RangeTableSample); - - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(method); - COPY_NODE_FIELD(args); - COPY_NODE_FIELD(repeatable); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static RangeTableFunc * -_copyRangeTableFunc(const RangeTableFunc *from) -{ - RangeTableFunc *newnode = makeNode(RangeTableFunc); - - COPY_SCALAR_FIELD(lateral); - COPY_NODE_FIELD(docexpr); - COPY_NODE_FIELD(rowexpr); - COPY_NODE_FIELD(namespaces); - COPY_NODE_FIELD(columns); - COPY_NODE_FIELD(alias); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static RangeTableFuncCol * -_copyRangeTableFuncCol(const RangeTableFuncCol *from) -{ - RangeTableFuncCol *newnode = makeNode(RangeTableFuncCol); - - COPY_STRING_FIELD(colname); - COPY_NODE_FIELD(typeName); - COPY_SCALAR_FIELD(for_ordinality); - COPY_SCALAR_FIELD(is_not_null); - COPY_NODE_FIELD(colexpr); - COPY_NODE_FIELD(coldefexpr); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static TypeCast * -_copyTypeCast(const TypeCast *from) -{ - TypeCast *newnode = makeNode(TypeCast); - - COPY_NODE_FIELD(arg); - COPY_NODE_FIELD(typeName); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static CollateClause * -_copyCollateClause(const CollateClause *from) -{ - CollateClause *newnode = makeNode(CollateClause); - - COPY_NODE_FIELD(arg); - COPY_NODE_FIELD(collname); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static IndexElem * -_copyIndexElem(const IndexElem *from) -{ - IndexElem *newnode = makeNode(IndexElem); - - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(expr); - COPY_STRING_FIELD(indexcolname); - COPY_NODE_FIELD(collation); - COPY_NODE_FIELD(opclass); - COPY_NODE_FIELD(opclassopts); - COPY_SCALAR_FIELD(ordering); - COPY_SCALAR_FIELD(nulls_ordering); - - return newnode; -} - -static StatsElem * -_copyStatsElem(const StatsElem *from) -{ - StatsElem *newnode = makeNode(StatsElem); - - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(expr); - - return newnode; -} - -static ColumnDef * -_copyColumnDef(const ColumnDef *from) -{ - ColumnDef *newnode = makeNode(ColumnDef); - - COPY_STRING_FIELD(colname); - COPY_NODE_FIELD(typeName); - COPY_STRING_FIELD(compression); - COPY_SCALAR_FIELD(inhcount); - COPY_SCALAR_FIELD(is_local); - COPY_SCALAR_FIELD(is_not_null); - COPY_SCALAR_FIELD(is_from_type); - COPY_SCALAR_FIELD(storage); - COPY_NODE_FIELD(raw_default); - COPY_NODE_FIELD(cooked_default); - COPY_SCALAR_FIELD(identity); - COPY_NODE_FIELD(identitySequence); - COPY_SCALAR_FIELD(generated); - COPY_NODE_FIELD(collClause); - COPY_SCALAR_FIELD(collOid); - COPY_NODE_FIELD(constraints); - COPY_NODE_FIELD(fdwoptions); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static Constraint * -_copyConstraint(const Constraint *from) -{ - Constraint *newnode = makeNode(Constraint); - - COPY_SCALAR_FIELD(contype); - COPY_STRING_FIELD(conname); - COPY_SCALAR_FIELD(deferrable); - COPY_SCALAR_FIELD(initdeferred); - COPY_LOCATION_FIELD(location); - COPY_SCALAR_FIELD(is_no_inherit); - COPY_NODE_FIELD(raw_expr); - COPY_STRING_FIELD(cooked_expr); - COPY_SCALAR_FIELD(generated_when); - COPY_SCALAR_FIELD(nulls_not_distinct); - COPY_NODE_FIELD(keys); - COPY_NODE_FIELD(including); - COPY_NODE_FIELD(exclusions); - COPY_NODE_FIELD(options); - COPY_STRING_FIELD(indexname); - COPY_STRING_FIELD(indexspace); - COPY_SCALAR_FIELD(reset_default_tblspc); - COPY_STRING_FIELD(access_method); - COPY_NODE_FIELD(where_clause); - COPY_NODE_FIELD(pktable); - COPY_NODE_FIELD(fk_attrs); - COPY_NODE_FIELD(pk_attrs); - COPY_SCALAR_FIELD(fk_matchtype); - COPY_SCALAR_FIELD(fk_upd_action); - COPY_SCALAR_FIELD(fk_del_action); - COPY_NODE_FIELD(fk_del_set_cols); - COPY_NODE_FIELD(old_conpfeqop); - COPY_SCALAR_FIELD(old_pktable_oid); - COPY_SCALAR_FIELD(skip_validation); - COPY_SCALAR_FIELD(initially_valid); - - return newnode; -} - -static DefElem * -_copyDefElem(const DefElem *from) -{ - DefElem *newnode = makeNode(DefElem); - - COPY_STRING_FIELD(defnamespace); - COPY_STRING_FIELD(defname); - COPY_NODE_FIELD(arg); - COPY_SCALAR_FIELD(defaction); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static LockingClause * -_copyLockingClause(const LockingClause *from) -{ - LockingClause *newnode = makeNode(LockingClause); - - COPY_NODE_FIELD(lockedRels); - COPY_SCALAR_FIELD(strength); - COPY_SCALAR_FIELD(waitPolicy); - - return newnode; -} - -static XmlSerialize * -_copyXmlSerialize(const XmlSerialize *from) -{ - XmlSerialize *newnode = makeNode(XmlSerialize); - - COPY_SCALAR_FIELD(xmloption); - COPY_NODE_FIELD(expr); - COPY_NODE_FIELD(typeName); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static RoleSpec * -_copyRoleSpec(const RoleSpec *from) -{ - RoleSpec *newnode = makeNode(RoleSpec); - - COPY_SCALAR_FIELD(roletype); - COPY_STRING_FIELD(rolename); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static TriggerTransition * -_copyTriggerTransition(const TriggerTransition *from) -{ - TriggerTransition *newnode = makeNode(TriggerTransition); - - COPY_STRING_FIELD(name); - COPY_SCALAR_FIELD(isNew); - COPY_SCALAR_FIELD(isTable); - - return newnode; -} - -static Query * -_copyQuery(const Query *from) -{ - Query *newnode = makeNode(Query); - - COPY_SCALAR_FIELD(commandType); - COPY_SCALAR_FIELD(querySource); - COPY_SCALAR_FIELD(queryId); - COPY_SCALAR_FIELD(canSetTag); - COPY_NODE_FIELD(utilityStmt); - COPY_SCALAR_FIELD(resultRelation); - COPY_SCALAR_FIELD(hasAggs); - COPY_SCALAR_FIELD(hasWindowFuncs); - COPY_SCALAR_FIELD(hasTargetSRFs); - COPY_SCALAR_FIELD(hasSubLinks); - COPY_SCALAR_FIELD(hasDistinctOn); - COPY_SCALAR_FIELD(hasRecursive); - COPY_SCALAR_FIELD(hasModifyingCTE); - COPY_SCALAR_FIELD(hasForUpdate); - COPY_SCALAR_FIELD(hasRowSecurity); - COPY_SCALAR_FIELD(isReturn); - COPY_NODE_FIELD(cteList); - COPY_NODE_FIELD(rtable); - COPY_NODE_FIELD(jointree); - COPY_NODE_FIELD(targetList); - COPY_SCALAR_FIELD(override); - COPY_NODE_FIELD(onConflict); - COPY_NODE_FIELD(returningList); - COPY_NODE_FIELD(groupClause); - COPY_SCALAR_FIELD(groupDistinct); - COPY_NODE_FIELD(groupingSets); - COPY_NODE_FIELD(havingQual); - COPY_NODE_FIELD(windowClause); - COPY_NODE_FIELD(distinctClause); - COPY_NODE_FIELD(sortClause); - COPY_NODE_FIELD(limitOffset); - COPY_NODE_FIELD(limitCount); - COPY_SCALAR_FIELD(limitOption); - COPY_NODE_FIELD(rowMarks); - COPY_NODE_FIELD(setOperations); - COPY_NODE_FIELD(constraintDeps); - COPY_NODE_FIELD(withCheckOptions); - COPY_NODE_FIELD(mergeActionList); - COPY_SCALAR_FIELD(mergeUseOuterJoin); - COPY_LOCATION_FIELD(stmt_location); - COPY_SCALAR_FIELD(stmt_len); - - return newnode; -} - -static RawStmt * -_copyRawStmt(const RawStmt *from) -{ - RawStmt *newnode = makeNode(RawStmt); - - COPY_NODE_FIELD(stmt); - COPY_LOCATION_FIELD(stmt_location); - COPY_SCALAR_FIELD(stmt_len); - - return newnode; -} - -static InsertStmt * -_copyInsertStmt(const InsertStmt *from) -{ - InsertStmt *newnode = makeNode(InsertStmt); - - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(cols); - COPY_NODE_FIELD(selectStmt); - COPY_NODE_FIELD(onConflictClause); - COPY_NODE_FIELD(returningList); - COPY_NODE_FIELD(withClause); - COPY_SCALAR_FIELD(override); - - return newnode; -} - -static DeleteStmt * -_copyDeleteStmt(const DeleteStmt *from) -{ - DeleteStmt *newnode = makeNode(DeleteStmt); - - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(usingClause); - COPY_NODE_FIELD(whereClause); - COPY_NODE_FIELD(returningList); - COPY_NODE_FIELD(withClause); - - return newnode; -} - -static UpdateStmt * -_copyUpdateStmt(const UpdateStmt *from) -{ - UpdateStmt *newnode = makeNode(UpdateStmt); - - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(targetList); - COPY_NODE_FIELD(whereClause); - COPY_NODE_FIELD(fromClause); - COPY_NODE_FIELD(returningList); - COPY_NODE_FIELD(withClause); - - return newnode; -} - -static MergeStmt * -_copyMergeStmt(const MergeStmt *from) -{ - MergeStmt *newnode = makeNode(MergeStmt); - - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(sourceRelation); - COPY_NODE_FIELD(joinCondition); - COPY_NODE_FIELD(mergeWhenClauses); - COPY_NODE_FIELD(withClause); - - return newnode; -} - -static SelectStmt * -_copySelectStmt(const SelectStmt *from) -{ - SelectStmt *newnode = makeNode(SelectStmt); - - COPY_NODE_FIELD(distinctClause); - COPY_NODE_FIELD(intoClause); - COPY_NODE_FIELD(targetList); - COPY_NODE_FIELD(fromClause); - COPY_NODE_FIELD(whereClause); - COPY_NODE_FIELD(groupClause); - COPY_SCALAR_FIELD(groupDistinct); - COPY_NODE_FIELD(havingClause); - COPY_NODE_FIELD(windowClause); - COPY_NODE_FIELD(valuesLists); - COPY_NODE_FIELD(sortClause); - COPY_NODE_FIELD(limitOffset); - COPY_NODE_FIELD(limitCount); - COPY_SCALAR_FIELD(limitOption); - COPY_NODE_FIELD(lockingClause); - COPY_NODE_FIELD(withClause); - COPY_SCALAR_FIELD(op); - COPY_SCALAR_FIELD(all); - COPY_NODE_FIELD(larg); - COPY_NODE_FIELD(rarg); - - return newnode; -} - -static SetOperationStmt * -_copySetOperationStmt(const SetOperationStmt *from) -{ - SetOperationStmt *newnode = makeNode(SetOperationStmt); - - COPY_SCALAR_FIELD(op); - COPY_SCALAR_FIELD(all); - COPY_NODE_FIELD(larg); - COPY_NODE_FIELD(rarg); - COPY_NODE_FIELD(colTypes); - COPY_NODE_FIELD(colTypmods); - COPY_NODE_FIELD(colCollations); - COPY_NODE_FIELD(groupClauses); - - return newnode; -} - -static ReturnStmt * -_copyReturnStmt(const ReturnStmt *from) -{ - ReturnStmt *newnode = makeNode(ReturnStmt); - - COPY_NODE_FIELD(returnval); - - return newnode; -} - -static PLAssignStmt * -_copyPLAssignStmt(const PLAssignStmt *from) -{ - PLAssignStmt *newnode = makeNode(PLAssignStmt); - - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(indirection); - COPY_SCALAR_FIELD(nnames); - COPY_NODE_FIELD(val); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static AlterTableStmt * -_copyAlterTableStmt(const AlterTableStmt *from) -{ - AlterTableStmt *newnode = makeNode(AlterTableStmt); - - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(cmds); - COPY_SCALAR_FIELD(objtype); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static AlterTableCmd * -_copyAlterTableCmd(const AlterTableCmd *from) -{ - AlterTableCmd *newnode = makeNode(AlterTableCmd); - - COPY_SCALAR_FIELD(subtype); - COPY_STRING_FIELD(name); - COPY_SCALAR_FIELD(num); - COPY_NODE_FIELD(newowner); - COPY_NODE_FIELD(def); - COPY_SCALAR_FIELD(behavior); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static AlterCollationStmt * -_copyAlterCollationStmt(const AlterCollationStmt *from) -{ - AlterCollationStmt *newnode = makeNode(AlterCollationStmt); - - COPY_NODE_FIELD(collname); - - return newnode; -} - -static AlterDomainStmt * -_copyAlterDomainStmt(const AlterDomainStmt *from) -{ - AlterDomainStmt *newnode = makeNode(AlterDomainStmt); - - COPY_SCALAR_FIELD(subtype); - COPY_NODE_FIELD(typeName); - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(def); - COPY_SCALAR_FIELD(behavior); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static GrantStmt * -_copyGrantStmt(const GrantStmt *from) -{ - GrantStmt *newnode = makeNode(GrantStmt); - - COPY_SCALAR_FIELD(is_grant); - COPY_SCALAR_FIELD(targtype); - COPY_SCALAR_FIELD(objtype); - COPY_NODE_FIELD(objects); - COPY_NODE_FIELD(privileges); - COPY_NODE_FIELD(grantees); - COPY_SCALAR_FIELD(grant_option); - COPY_NODE_FIELD(grantor); - COPY_SCALAR_FIELD(behavior); - - return newnode; -} - -static ObjectWithArgs * -_copyObjectWithArgs(const ObjectWithArgs *from) -{ - ObjectWithArgs *newnode = makeNode(ObjectWithArgs); - - COPY_NODE_FIELD(objname); - COPY_NODE_FIELD(objargs); - COPY_NODE_FIELD(objfuncargs); - COPY_SCALAR_FIELD(args_unspecified); - - return newnode; -} - -static AccessPriv * -_copyAccessPriv(const AccessPriv *from) -{ - AccessPriv *newnode = makeNode(AccessPriv); - - COPY_STRING_FIELD(priv_name); - COPY_NODE_FIELD(cols); - - return newnode; -} - -static GrantRoleStmt * -_copyGrantRoleStmt(const GrantRoleStmt *from) -{ - GrantRoleStmt *newnode = makeNode(GrantRoleStmt); - - COPY_NODE_FIELD(granted_roles); - COPY_NODE_FIELD(grantee_roles); - COPY_SCALAR_FIELD(is_grant); - COPY_SCALAR_FIELD(admin_opt); - COPY_NODE_FIELD(grantor); - COPY_SCALAR_FIELD(behavior); - - return newnode; -} - -static AlterDefaultPrivilegesStmt * -_copyAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *from) -{ - AlterDefaultPrivilegesStmt *newnode = makeNode(AlterDefaultPrivilegesStmt); - - COPY_NODE_FIELD(options); - COPY_NODE_FIELD(action); - - return newnode; -} - -static DeclareCursorStmt * -_copyDeclareCursorStmt(const DeclareCursorStmt *from) -{ - DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt); - - COPY_STRING_FIELD(portalname); - COPY_SCALAR_FIELD(options); - COPY_NODE_FIELD(query); - - return newnode; -} - -static ClosePortalStmt * -_copyClosePortalStmt(const ClosePortalStmt *from) -{ - ClosePortalStmt *newnode = makeNode(ClosePortalStmt); - - COPY_STRING_FIELD(portalname); - - return newnode; -} - -static CallStmt * -_copyCallStmt(const CallStmt *from) -{ - CallStmt *newnode = makeNode(CallStmt); - - COPY_NODE_FIELD(funccall); - COPY_NODE_FIELD(funcexpr); - COPY_NODE_FIELD(outargs); - - return newnode; -} - -static ClusterStmt * -_copyClusterStmt(const ClusterStmt *from) -{ - ClusterStmt *newnode = makeNode(ClusterStmt); - - COPY_NODE_FIELD(relation); - COPY_STRING_FIELD(indexname); - COPY_NODE_FIELD(params); - - return newnode; -} - -static CopyStmt * -_copyCopyStmt(const CopyStmt *from) -{ - CopyStmt *newnode = makeNode(CopyStmt); - - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(query); - COPY_NODE_FIELD(attlist); - COPY_SCALAR_FIELD(is_from); - COPY_SCALAR_FIELD(is_program); - COPY_STRING_FIELD(filename); - COPY_NODE_FIELD(options); - COPY_NODE_FIELD(whereClause); - - return newnode; -} - -/* - * CopyCreateStmtFields - * - * This function copies the fields of the CreateStmt node. It is used by - * copy functions for classes which inherit from CreateStmt. - */ -static void -CopyCreateStmtFields(const CreateStmt *from, CreateStmt *newnode) -{ - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(tableElts); - COPY_NODE_FIELD(inhRelations); - COPY_NODE_FIELD(partspec); - COPY_NODE_FIELD(partbound); - COPY_NODE_FIELD(ofTypename); - COPY_NODE_FIELD(constraints); - COPY_NODE_FIELD(options); - COPY_SCALAR_FIELD(oncommit); - COPY_STRING_FIELD(tablespacename); - COPY_STRING_FIELD(accessMethod); - COPY_SCALAR_FIELD(if_not_exists); -} - -static CreateStmt * -_copyCreateStmt(const CreateStmt *from) -{ - CreateStmt *newnode = makeNode(CreateStmt); - - CopyCreateStmtFields(from, newnode); - - return newnode; -} - -static TableLikeClause * -_copyTableLikeClause(const TableLikeClause *from) -{ - TableLikeClause *newnode = makeNode(TableLikeClause); - - COPY_NODE_FIELD(relation); - COPY_SCALAR_FIELD(options); - COPY_SCALAR_FIELD(relationOid); - - return newnode; -} - -static DefineStmt * -_copyDefineStmt(const DefineStmt *from) -{ - DefineStmt *newnode = makeNode(DefineStmt); - - COPY_SCALAR_FIELD(kind); - COPY_SCALAR_FIELD(oldstyle); - COPY_NODE_FIELD(defnames); - COPY_NODE_FIELD(args); - COPY_NODE_FIELD(definition); - COPY_SCALAR_FIELD(if_not_exists); - COPY_SCALAR_FIELD(replace); - - return newnode; -} - -static DropStmt * -_copyDropStmt(const DropStmt *from) -{ - DropStmt *newnode = makeNode(DropStmt); - - COPY_NODE_FIELD(objects); - COPY_SCALAR_FIELD(removeType); - COPY_SCALAR_FIELD(behavior); - COPY_SCALAR_FIELD(missing_ok); - COPY_SCALAR_FIELD(concurrent); - - return newnode; -} - -static TruncateStmt * -_copyTruncateStmt(const TruncateStmt *from) -{ - TruncateStmt *newnode = makeNode(TruncateStmt); - - COPY_NODE_FIELD(relations); - COPY_SCALAR_FIELD(restart_seqs); - COPY_SCALAR_FIELD(behavior); - - return newnode; -} - -static CommentStmt * -_copyCommentStmt(const CommentStmt *from) -{ - CommentStmt *newnode = makeNode(CommentStmt); - - COPY_SCALAR_FIELD(objtype); - COPY_NODE_FIELD(object); - COPY_STRING_FIELD(comment); - - return newnode; -} - -static SecLabelStmt * -_copySecLabelStmt(const SecLabelStmt *from) -{ - SecLabelStmt *newnode = makeNode(SecLabelStmt); - - COPY_SCALAR_FIELD(objtype); - COPY_NODE_FIELD(object); - COPY_STRING_FIELD(provider); - COPY_STRING_FIELD(label); - - return newnode; -} - -static FetchStmt * -_copyFetchStmt(const FetchStmt *from) -{ - FetchStmt *newnode = makeNode(FetchStmt); - - COPY_SCALAR_FIELD(direction); - COPY_SCALAR_FIELD(howMany); - COPY_STRING_FIELD(portalname); - COPY_SCALAR_FIELD(ismove); - - return newnode; -} - -static IndexStmt * -_copyIndexStmt(const IndexStmt *from) -{ - IndexStmt *newnode = makeNode(IndexStmt); - - COPY_STRING_FIELD(idxname); - COPY_NODE_FIELD(relation); - COPY_STRING_FIELD(accessMethod); - COPY_STRING_FIELD(tableSpace); - COPY_NODE_FIELD(indexParams); - COPY_NODE_FIELD(indexIncludingParams); - COPY_NODE_FIELD(options); - COPY_NODE_FIELD(whereClause); - COPY_NODE_FIELD(excludeOpNames); - COPY_STRING_FIELD(idxcomment); - COPY_SCALAR_FIELD(indexOid); - COPY_SCALAR_FIELD(oldNumber); - COPY_SCALAR_FIELD(oldCreateSubid); - COPY_SCALAR_FIELD(oldFirstRelfilelocatorSubid); - COPY_SCALAR_FIELD(unique); - COPY_SCALAR_FIELD(nulls_not_distinct); - COPY_SCALAR_FIELD(primary); - COPY_SCALAR_FIELD(isconstraint); - COPY_SCALAR_FIELD(deferrable); - COPY_SCALAR_FIELD(initdeferred); - COPY_SCALAR_FIELD(transformed); - COPY_SCALAR_FIELD(concurrent); - COPY_SCALAR_FIELD(if_not_exists); - COPY_SCALAR_FIELD(reset_default_tblspc); - - return newnode; -} - -static CreateStatsStmt * -_copyCreateStatsStmt(const CreateStatsStmt *from) -{ - CreateStatsStmt *newnode = makeNode(CreateStatsStmt); - - COPY_NODE_FIELD(defnames); - COPY_NODE_FIELD(stat_types); - COPY_NODE_FIELD(exprs); - COPY_NODE_FIELD(relations); - COPY_STRING_FIELD(stxcomment); - COPY_SCALAR_FIELD(transformed); - COPY_SCALAR_FIELD(if_not_exists); - - return newnode; -} - -static AlterStatsStmt * -_copyAlterStatsStmt(const AlterStatsStmt *from) -{ - AlterStatsStmt *newnode = makeNode(AlterStatsStmt); - - COPY_NODE_FIELD(defnames); - COPY_SCALAR_FIELD(stxstattarget); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static CreateFunctionStmt * -_copyCreateFunctionStmt(const CreateFunctionStmt *from) -{ - CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt); - - COPY_SCALAR_FIELD(is_procedure); - COPY_SCALAR_FIELD(replace); - COPY_NODE_FIELD(funcname); - COPY_NODE_FIELD(parameters); - COPY_NODE_FIELD(returnType); - COPY_NODE_FIELD(options); - COPY_NODE_FIELD(sql_body); - - return newnode; -} - -static FunctionParameter * -_copyFunctionParameter(const FunctionParameter *from) -{ - FunctionParameter *newnode = makeNode(FunctionParameter); - - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(argType); - COPY_SCALAR_FIELD(mode); - COPY_NODE_FIELD(defexpr); - - return newnode; -} - -static AlterFunctionStmt * -_copyAlterFunctionStmt(const AlterFunctionStmt *from) -{ - AlterFunctionStmt *newnode = makeNode(AlterFunctionStmt); - - COPY_SCALAR_FIELD(objtype); - COPY_NODE_FIELD(func); - COPY_NODE_FIELD(actions); - - return newnode; -} - -static DoStmt * -_copyDoStmt(const DoStmt *from) -{ - DoStmt *newnode = makeNode(DoStmt); - - COPY_NODE_FIELD(args); - - return newnode; -} - -static RenameStmt * -_copyRenameStmt(const RenameStmt *from) -{ - RenameStmt *newnode = makeNode(RenameStmt); - - COPY_SCALAR_FIELD(renameType); - COPY_SCALAR_FIELD(relationType); - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(object); - COPY_STRING_FIELD(subname); - COPY_STRING_FIELD(newname); - COPY_SCALAR_FIELD(behavior); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static AlterObjectDependsStmt * -_copyAlterObjectDependsStmt(const AlterObjectDependsStmt *from) -{ - AlterObjectDependsStmt *newnode = makeNode(AlterObjectDependsStmt); - - COPY_SCALAR_FIELD(objectType); - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(object); - COPY_NODE_FIELD(extname); - COPY_SCALAR_FIELD(remove); - - return newnode; -} - -static AlterObjectSchemaStmt * -_copyAlterObjectSchemaStmt(const AlterObjectSchemaStmt *from) -{ - AlterObjectSchemaStmt *newnode = makeNode(AlterObjectSchemaStmt); - - COPY_SCALAR_FIELD(objectType); - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(object); - COPY_STRING_FIELD(newschema); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static AlterOwnerStmt * -_copyAlterOwnerStmt(const AlterOwnerStmt *from) -{ - AlterOwnerStmt *newnode = makeNode(AlterOwnerStmt); - - COPY_SCALAR_FIELD(objectType); - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(object); - COPY_NODE_FIELD(newowner); - - return newnode; -} - -static AlterOperatorStmt * -_copyAlterOperatorStmt(const AlterOperatorStmt *from) -{ - AlterOperatorStmt *newnode = makeNode(AlterOperatorStmt); - - COPY_NODE_FIELD(opername); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterTypeStmt * -_copyAlterTypeStmt(const AlterTypeStmt *from) -{ - AlterTypeStmt *newnode = makeNode(AlterTypeStmt); - - COPY_NODE_FIELD(typeName); - COPY_NODE_FIELD(options); - - return newnode; -} - -static RuleStmt * -_copyRuleStmt(const RuleStmt *from) -{ - RuleStmt *newnode = makeNode(RuleStmt); - - COPY_NODE_FIELD(relation); - COPY_STRING_FIELD(rulename); - COPY_NODE_FIELD(whereClause); - COPY_SCALAR_FIELD(event); - COPY_SCALAR_FIELD(instead); - COPY_NODE_FIELD(actions); - COPY_SCALAR_FIELD(replace); - - return newnode; -} - -static NotifyStmt * -_copyNotifyStmt(const NotifyStmt *from) -{ - NotifyStmt *newnode = makeNode(NotifyStmt); - - COPY_STRING_FIELD(conditionname); - COPY_STRING_FIELD(payload); - - return newnode; -} - -static ListenStmt * -_copyListenStmt(const ListenStmt *from) -{ - ListenStmt *newnode = makeNode(ListenStmt); - - COPY_STRING_FIELD(conditionname); - - return newnode; -} - -static UnlistenStmt * -_copyUnlistenStmt(const UnlistenStmt *from) -{ - UnlistenStmt *newnode = makeNode(UnlistenStmt); - - COPY_STRING_FIELD(conditionname); - - return newnode; -} - -static TransactionStmt * -_copyTransactionStmt(const TransactionStmt *from) -{ - TransactionStmt *newnode = makeNode(TransactionStmt); - - COPY_SCALAR_FIELD(kind); - COPY_NODE_FIELD(options); - COPY_STRING_FIELD(savepoint_name); - COPY_STRING_FIELD(gid); - COPY_SCALAR_FIELD(chain); - - return newnode; -} - -static CompositeTypeStmt * -_copyCompositeTypeStmt(const CompositeTypeStmt *from) -{ - CompositeTypeStmt *newnode = makeNode(CompositeTypeStmt); - - COPY_NODE_FIELD(typevar); - COPY_NODE_FIELD(coldeflist); - - return newnode; -} - -static CreateEnumStmt * -_copyCreateEnumStmt(const CreateEnumStmt *from) -{ - CreateEnumStmt *newnode = makeNode(CreateEnumStmt); - - COPY_NODE_FIELD(typeName); - COPY_NODE_FIELD(vals); - - return newnode; -} - -static CreateRangeStmt * -_copyCreateRangeStmt(const CreateRangeStmt *from) -{ - CreateRangeStmt *newnode = makeNode(CreateRangeStmt); - - COPY_NODE_FIELD(typeName); - COPY_NODE_FIELD(params); - - return newnode; -} - -static AlterEnumStmt * -_copyAlterEnumStmt(const AlterEnumStmt *from) -{ - AlterEnumStmt *newnode = makeNode(AlterEnumStmt); - - COPY_NODE_FIELD(typeName); - COPY_STRING_FIELD(oldVal); - COPY_STRING_FIELD(newVal); - COPY_STRING_FIELD(newValNeighbor); - COPY_SCALAR_FIELD(newValIsAfter); - COPY_SCALAR_FIELD(skipIfNewValExists); - - return newnode; -} - -static ViewStmt * -_copyViewStmt(const ViewStmt *from) -{ - ViewStmt *newnode = makeNode(ViewStmt); - - COPY_NODE_FIELD(view); - COPY_NODE_FIELD(aliases); - COPY_NODE_FIELD(query); - COPY_SCALAR_FIELD(replace); - COPY_NODE_FIELD(options); - COPY_SCALAR_FIELD(withCheckOption); - - return newnode; -} - -static LoadStmt * -_copyLoadStmt(const LoadStmt *from) -{ - LoadStmt *newnode = makeNode(LoadStmt); - - COPY_STRING_FIELD(filename); - - return newnode; -} - -static CreateDomainStmt * -_copyCreateDomainStmt(const CreateDomainStmt *from) -{ - CreateDomainStmt *newnode = makeNode(CreateDomainStmt); - - COPY_NODE_FIELD(domainname); - COPY_NODE_FIELD(typeName); - COPY_NODE_FIELD(collClause); - COPY_NODE_FIELD(constraints); - - return newnode; -} - -static CreateOpClassStmt * -_copyCreateOpClassStmt(const CreateOpClassStmt *from) -{ - CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt); - - COPY_NODE_FIELD(opclassname); - COPY_NODE_FIELD(opfamilyname); - COPY_STRING_FIELD(amname); - COPY_NODE_FIELD(datatype); - COPY_NODE_FIELD(items); - COPY_SCALAR_FIELD(isDefault); - - return newnode; -} - -static CreateOpClassItem * -_copyCreateOpClassItem(const CreateOpClassItem *from) -{ - CreateOpClassItem *newnode = makeNode(CreateOpClassItem); - - COPY_SCALAR_FIELD(itemtype); - COPY_NODE_FIELD(name); - COPY_SCALAR_FIELD(number); - COPY_NODE_FIELD(order_family); - COPY_NODE_FIELD(class_args); - COPY_NODE_FIELD(storedtype); - - return newnode; -} - -static CreateOpFamilyStmt * -_copyCreateOpFamilyStmt(const CreateOpFamilyStmt *from) -{ - CreateOpFamilyStmt *newnode = makeNode(CreateOpFamilyStmt); - - COPY_NODE_FIELD(opfamilyname); - COPY_STRING_FIELD(amname); - - return newnode; -} - -static AlterOpFamilyStmt * -_copyAlterOpFamilyStmt(const AlterOpFamilyStmt *from) -{ - AlterOpFamilyStmt *newnode = makeNode(AlterOpFamilyStmt); - - COPY_NODE_FIELD(opfamilyname); - COPY_STRING_FIELD(amname); - COPY_SCALAR_FIELD(isDrop); - COPY_NODE_FIELD(items); - - return newnode; -} - -static CreatedbStmt * -_copyCreatedbStmt(const CreatedbStmt *from) -{ - CreatedbStmt *newnode = makeNode(CreatedbStmt); - - COPY_STRING_FIELD(dbname); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterDatabaseStmt * -_copyAlterDatabaseStmt(const AlterDatabaseStmt *from) -{ - AlterDatabaseStmt *newnode = makeNode(AlterDatabaseStmt); - - COPY_STRING_FIELD(dbname); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterDatabaseRefreshCollStmt * -_copyAlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt *from) -{ - AlterDatabaseRefreshCollStmt *newnode = makeNode(AlterDatabaseRefreshCollStmt); - - COPY_STRING_FIELD(dbname); - - return newnode; -} - -static AlterDatabaseSetStmt * -_copyAlterDatabaseSetStmt(const AlterDatabaseSetStmt *from) -{ - AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt); - - COPY_STRING_FIELD(dbname); - COPY_NODE_FIELD(setstmt); - - return newnode; -} - -static DropdbStmt * -_copyDropdbStmt(const DropdbStmt *from) -{ - DropdbStmt *newnode = makeNode(DropdbStmt); - - COPY_STRING_FIELD(dbname); - COPY_SCALAR_FIELD(missing_ok); - COPY_NODE_FIELD(options); - - return newnode; -} - -static VacuumStmt * -_copyVacuumStmt(const VacuumStmt *from) -{ - VacuumStmt *newnode = makeNode(VacuumStmt); - - COPY_NODE_FIELD(options); - COPY_NODE_FIELD(rels); - COPY_SCALAR_FIELD(is_vacuumcmd); - - return newnode; -} - -static VacuumRelation * -_copyVacuumRelation(const VacuumRelation *from) -{ - VacuumRelation *newnode = makeNode(VacuumRelation); - - COPY_NODE_FIELD(relation); - COPY_SCALAR_FIELD(oid); - COPY_NODE_FIELD(va_cols); - - return newnode; -} - -static ExplainStmt * -_copyExplainStmt(const ExplainStmt *from) -{ - ExplainStmt *newnode = makeNode(ExplainStmt); - - COPY_NODE_FIELD(query); - COPY_NODE_FIELD(options); - - return newnode; -} - -static CreateTableAsStmt * -_copyCreateTableAsStmt(const CreateTableAsStmt *from) -{ - CreateTableAsStmt *newnode = makeNode(CreateTableAsStmt); - - COPY_NODE_FIELD(query); - COPY_NODE_FIELD(into); - COPY_SCALAR_FIELD(objtype); - COPY_SCALAR_FIELD(is_select_into); - COPY_SCALAR_FIELD(if_not_exists); - - return newnode; -} - -static RefreshMatViewStmt * -_copyRefreshMatViewStmt(const RefreshMatViewStmt *from) -{ - RefreshMatViewStmt *newnode = makeNode(RefreshMatViewStmt); - - COPY_SCALAR_FIELD(concurrent); - COPY_SCALAR_FIELD(skipData); - COPY_NODE_FIELD(relation); - - return newnode; -} - -static ReplicaIdentityStmt * -_copyReplicaIdentityStmt(const ReplicaIdentityStmt *from) -{ - ReplicaIdentityStmt *newnode = makeNode(ReplicaIdentityStmt); - - COPY_SCALAR_FIELD(identity_type); - COPY_STRING_FIELD(name); - - return newnode; -} - -static AlterSystemStmt * -_copyAlterSystemStmt(const AlterSystemStmt *from) -{ - AlterSystemStmt *newnode = makeNode(AlterSystemStmt); - - COPY_NODE_FIELD(setstmt); - - return newnode; -} - -static CreateSeqStmt * -_copyCreateSeqStmt(const CreateSeqStmt *from) -{ - CreateSeqStmt *newnode = makeNode(CreateSeqStmt); - - COPY_NODE_FIELD(sequence); - COPY_NODE_FIELD(options); - COPY_SCALAR_FIELD(ownerId); - COPY_SCALAR_FIELD(for_identity); - COPY_SCALAR_FIELD(if_not_exists); - - return newnode; -} - -static AlterSeqStmt * -_copyAlterSeqStmt(const AlterSeqStmt *from) -{ - AlterSeqStmt *newnode = makeNode(AlterSeqStmt); - - COPY_NODE_FIELD(sequence); - COPY_NODE_FIELD(options); - COPY_SCALAR_FIELD(for_identity); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static VariableSetStmt * -_copyVariableSetStmt(const VariableSetStmt *from) -{ - VariableSetStmt *newnode = makeNode(VariableSetStmt); - - COPY_SCALAR_FIELD(kind); - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(args); - COPY_SCALAR_FIELD(is_local); - - return newnode; -} - -static VariableShowStmt * -_copyVariableShowStmt(const VariableShowStmt *from) -{ - VariableShowStmt *newnode = makeNode(VariableShowStmt); - - COPY_STRING_FIELD(name); - - return newnode; -} - -static DiscardStmt * -_copyDiscardStmt(const DiscardStmt *from) -{ - DiscardStmt *newnode = makeNode(DiscardStmt); - - COPY_SCALAR_FIELD(target); - - return newnode; -} - -static CreateTableSpaceStmt * -_copyCreateTableSpaceStmt(const CreateTableSpaceStmt *from) -{ - CreateTableSpaceStmt *newnode = makeNode(CreateTableSpaceStmt); - - COPY_STRING_FIELD(tablespacename); - COPY_NODE_FIELD(owner); - COPY_STRING_FIELD(location); - COPY_NODE_FIELD(options); - - return newnode; -} - -static DropTableSpaceStmt * -_copyDropTableSpaceStmt(const DropTableSpaceStmt *from) -{ - DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt); - - COPY_STRING_FIELD(tablespacename); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static AlterTableSpaceOptionsStmt * -_copyAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *from) -{ - AlterTableSpaceOptionsStmt *newnode = makeNode(AlterTableSpaceOptionsStmt); - - COPY_STRING_FIELD(tablespacename); - COPY_NODE_FIELD(options); - COPY_SCALAR_FIELD(isReset); - - return newnode; -} - -static AlterTableMoveAllStmt * -_copyAlterTableMoveAllStmt(const AlterTableMoveAllStmt *from) -{ - AlterTableMoveAllStmt *newnode = makeNode(AlterTableMoveAllStmt); - - COPY_STRING_FIELD(orig_tablespacename); - COPY_SCALAR_FIELD(objtype); - COPY_NODE_FIELD(roles); - COPY_STRING_FIELD(new_tablespacename); - COPY_SCALAR_FIELD(nowait); - - return newnode; -} - -static CreateExtensionStmt * -_copyCreateExtensionStmt(const CreateExtensionStmt *from) -{ - CreateExtensionStmt *newnode = makeNode(CreateExtensionStmt); - - COPY_STRING_FIELD(extname); - COPY_SCALAR_FIELD(if_not_exists); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterExtensionStmt * -_copyAlterExtensionStmt(const AlterExtensionStmt *from) -{ - AlterExtensionStmt *newnode = makeNode(AlterExtensionStmt); - - COPY_STRING_FIELD(extname); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterExtensionContentsStmt * -_copyAlterExtensionContentsStmt(const AlterExtensionContentsStmt *from) -{ - AlterExtensionContentsStmt *newnode = makeNode(AlterExtensionContentsStmt); - - COPY_STRING_FIELD(extname); - COPY_SCALAR_FIELD(action); - COPY_SCALAR_FIELD(objtype); - COPY_NODE_FIELD(object); - - return newnode; -} - -static CreateFdwStmt * -_copyCreateFdwStmt(const CreateFdwStmt *from) -{ - CreateFdwStmt *newnode = makeNode(CreateFdwStmt); - - COPY_STRING_FIELD(fdwname); - COPY_NODE_FIELD(func_options); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterFdwStmt * -_copyAlterFdwStmt(const AlterFdwStmt *from) -{ - AlterFdwStmt *newnode = makeNode(AlterFdwStmt); - - COPY_STRING_FIELD(fdwname); - COPY_NODE_FIELD(func_options); - COPY_NODE_FIELD(options); - - return newnode; -} - -static CreateForeignServerStmt * -_copyCreateForeignServerStmt(const CreateForeignServerStmt *from) -{ - CreateForeignServerStmt *newnode = makeNode(CreateForeignServerStmt); - - COPY_STRING_FIELD(servername); - COPY_STRING_FIELD(servertype); - COPY_STRING_FIELD(version); - COPY_STRING_FIELD(fdwname); - COPY_SCALAR_FIELD(if_not_exists); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterForeignServerStmt * -_copyAlterForeignServerStmt(const AlterForeignServerStmt *from) -{ - AlterForeignServerStmt *newnode = makeNode(AlterForeignServerStmt); - - COPY_STRING_FIELD(servername); - COPY_STRING_FIELD(version); - COPY_NODE_FIELD(options); - COPY_SCALAR_FIELD(has_version); - - return newnode; -} - -static CreateUserMappingStmt * -_copyCreateUserMappingStmt(const CreateUserMappingStmt *from) -{ - CreateUserMappingStmt *newnode = makeNode(CreateUserMappingStmt); - - COPY_NODE_FIELD(user); - COPY_STRING_FIELD(servername); - COPY_SCALAR_FIELD(if_not_exists); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterUserMappingStmt * -_copyAlterUserMappingStmt(const AlterUserMappingStmt *from) -{ - AlterUserMappingStmt *newnode = makeNode(AlterUserMappingStmt); - - COPY_NODE_FIELD(user); - COPY_STRING_FIELD(servername); - COPY_NODE_FIELD(options); - - return newnode; -} - -static DropUserMappingStmt * -_copyDropUserMappingStmt(const DropUserMappingStmt *from) -{ - DropUserMappingStmt *newnode = makeNode(DropUserMappingStmt); - - COPY_NODE_FIELD(user); - COPY_STRING_FIELD(servername); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static CreateForeignTableStmt * -_copyCreateForeignTableStmt(const CreateForeignTableStmt *from) -{ - CreateForeignTableStmt *newnode = makeNode(CreateForeignTableStmt); - - CopyCreateStmtFields((const CreateStmt *) from, (CreateStmt *) newnode); - - COPY_STRING_FIELD(servername); - COPY_NODE_FIELD(options); - - return newnode; -} - -static ImportForeignSchemaStmt * -_copyImportForeignSchemaStmt(const ImportForeignSchemaStmt *from) -{ - ImportForeignSchemaStmt *newnode = makeNode(ImportForeignSchemaStmt); - - COPY_STRING_FIELD(server_name); - COPY_STRING_FIELD(remote_schema); - COPY_STRING_FIELD(local_schema); - COPY_SCALAR_FIELD(list_type); - COPY_NODE_FIELD(table_list); - COPY_NODE_FIELD(options); - - return newnode; -} - -static CreateTransformStmt * -_copyCreateTransformStmt(const CreateTransformStmt *from) -{ - CreateTransformStmt *newnode = makeNode(CreateTransformStmt); - - COPY_SCALAR_FIELD(replace); - COPY_NODE_FIELD(type_name); - COPY_STRING_FIELD(lang); - COPY_NODE_FIELD(fromsql); - COPY_NODE_FIELD(tosql); - - return newnode; -} - -static CreateAmStmt * -_copyCreateAmStmt(const CreateAmStmt *from) -{ - CreateAmStmt *newnode = makeNode(CreateAmStmt); - - COPY_STRING_FIELD(amname); - COPY_NODE_FIELD(handler_name); - COPY_SCALAR_FIELD(amtype); - - return newnode; -} - -static CreateTrigStmt * -_copyCreateTrigStmt(const CreateTrigStmt *from) -{ - CreateTrigStmt *newnode = makeNode(CreateTrigStmt); - - COPY_SCALAR_FIELD(replace); - COPY_SCALAR_FIELD(isconstraint); - COPY_STRING_FIELD(trigname); - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(funcname); - COPY_NODE_FIELD(args); - COPY_SCALAR_FIELD(row); - COPY_SCALAR_FIELD(timing); - COPY_SCALAR_FIELD(events); - COPY_NODE_FIELD(columns); - COPY_NODE_FIELD(whenClause); - COPY_NODE_FIELD(transitionRels); - COPY_SCALAR_FIELD(deferrable); - COPY_SCALAR_FIELD(initdeferred); - COPY_NODE_FIELD(constrrel); - - return newnode; -} - -static CreateEventTrigStmt * -_copyCreateEventTrigStmt(const CreateEventTrigStmt *from) -{ - CreateEventTrigStmt *newnode = makeNode(CreateEventTrigStmt); - - COPY_STRING_FIELD(trigname); - COPY_STRING_FIELD(eventname); - COPY_NODE_FIELD(whenclause); - COPY_NODE_FIELD(funcname); - - return newnode; -} - -static AlterEventTrigStmt * -_copyAlterEventTrigStmt(const AlterEventTrigStmt *from) -{ - AlterEventTrigStmt *newnode = makeNode(AlterEventTrigStmt); - - COPY_STRING_FIELD(trigname); - COPY_SCALAR_FIELD(tgenabled); - - return newnode; -} - -static CreatePLangStmt * -_copyCreatePLangStmt(const CreatePLangStmt *from) -{ - CreatePLangStmt *newnode = makeNode(CreatePLangStmt); - - COPY_SCALAR_FIELD(replace); - COPY_STRING_FIELD(plname); - COPY_NODE_FIELD(plhandler); - COPY_NODE_FIELD(plinline); - COPY_NODE_FIELD(plvalidator); - COPY_SCALAR_FIELD(pltrusted); - - return newnode; -} - -static CreateRoleStmt * -_copyCreateRoleStmt(const CreateRoleStmt *from) -{ - CreateRoleStmt *newnode = makeNode(CreateRoleStmt); - - COPY_SCALAR_FIELD(stmt_type); - COPY_STRING_FIELD(role); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterRoleStmt * -_copyAlterRoleStmt(const AlterRoleStmt *from) -{ - AlterRoleStmt *newnode = makeNode(AlterRoleStmt); - - COPY_NODE_FIELD(role); - COPY_NODE_FIELD(options); - COPY_SCALAR_FIELD(action); - - return newnode; -} - -static AlterRoleSetStmt * -_copyAlterRoleSetStmt(const AlterRoleSetStmt *from) -{ - AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt); - - COPY_NODE_FIELD(role); - COPY_STRING_FIELD(database); - COPY_NODE_FIELD(setstmt); - - return newnode; -} - -static DropRoleStmt * -_copyDropRoleStmt(const DropRoleStmt *from) -{ - DropRoleStmt *newnode = makeNode(DropRoleStmt); - - COPY_NODE_FIELD(roles); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static LockStmt * -_copyLockStmt(const LockStmt *from) -{ - LockStmt *newnode = makeNode(LockStmt); - - COPY_NODE_FIELD(relations); - COPY_SCALAR_FIELD(mode); - COPY_SCALAR_FIELD(nowait); - - return newnode; -} - -static ConstraintsSetStmt * -_copyConstraintsSetStmt(const ConstraintsSetStmt *from) -{ - ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt); - - COPY_NODE_FIELD(constraints); - COPY_SCALAR_FIELD(deferred); - - return newnode; -} - -static ReindexStmt * -_copyReindexStmt(const ReindexStmt *from) -{ - ReindexStmt *newnode = makeNode(ReindexStmt); - - COPY_SCALAR_FIELD(kind); - COPY_NODE_FIELD(relation); - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(params); - - return newnode; -} - -static CreateSchemaStmt * -_copyCreateSchemaStmt(const CreateSchemaStmt *from) -{ - CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt); - - COPY_STRING_FIELD(schemaname); - COPY_NODE_FIELD(authrole); - COPY_NODE_FIELD(schemaElts); - COPY_SCALAR_FIELD(if_not_exists); - - return newnode; -} - -static CreateConversionStmt * -_copyCreateConversionStmt(const CreateConversionStmt *from) -{ - CreateConversionStmt *newnode = makeNode(CreateConversionStmt); - - COPY_NODE_FIELD(conversion_name); - COPY_STRING_FIELD(for_encoding_name); - COPY_STRING_FIELD(to_encoding_name); - COPY_NODE_FIELD(func_name); - COPY_SCALAR_FIELD(def); - - return newnode; -} - -static CreateCastStmt * -_copyCreateCastStmt(const CreateCastStmt *from) -{ - CreateCastStmt *newnode = makeNode(CreateCastStmt); - - COPY_NODE_FIELD(sourcetype); - COPY_NODE_FIELD(targettype); - COPY_NODE_FIELD(func); - COPY_SCALAR_FIELD(context); - COPY_SCALAR_FIELD(inout); - - return newnode; -} - -static PrepareStmt * -_copyPrepareStmt(const PrepareStmt *from) -{ - PrepareStmt *newnode = makeNode(PrepareStmt); - - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(argtypes); - COPY_NODE_FIELD(query); - - return newnode; -} - -static ExecuteStmt * -_copyExecuteStmt(const ExecuteStmt *from) -{ - ExecuteStmt *newnode = makeNode(ExecuteStmt); - - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(params); - - return newnode; -} - -static DeallocateStmt * -_copyDeallocateStmt(const DeallocateStmt *from) -{ - DeallocateStmt *newnode = makeNode(DeallocateStmt); - - COPY_STRING_FIELD(name); - - return newnode; -} - -static DropOwnedStmt * -_copyDropOwnedStmt(const DropOwnedStmt *from) -{ - DropOwnedStmt *newnode = makeNode(DropOwnedStmt); - - COPY_NODE_FIELD(roles); - COPY_SCALAR_FIELD(behavior); - - return newnode; -} - -static ReassignOwnedStmt * -_copyReassignOwnedStmt(const ReassignOwnedStmt *from) -{ - ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt); - - COPY_NODE_FIELD(roles); - COPY_NODE_FIELD(newrole); - - return newnode; -} - -static AlterTSDictionaryStmt * -_copyAlterTSDictionaryStmt(const AlterTSDictionaryStmt *from) -{ - AlterTSDictionaryStmt *newnode = makeNode(AlterTSDictionaryStmt); - - COPY_NODE_FIELD(dictname); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterTSConfigurationStmt * -_copyAlterTSConfigurationStmt(const AlterTSConfigurationStmt *from) -{ - AlterTSConfigurationStmt *newnode = makeNode(AlterTSConfigurationStmt); - - COPY_SCALAR_FIELD(kind); - COPY_NODE_FIELD(cfgname); - COPY_NODE_FIELD(tokentype); - COPY_NODE_FIELD(dicts); - COPY_SCALAR_FIELD(override); - COPY_SCALAR_FIELD(replace); - COPY_SCALAR_FIELD(missing_ok); - - return newnode; -} - -static CreatePolicyStmt * -_copyCreatePolicyStmt(const CreatePolicyStmt *from) -{ - CreatePolicyStmt *newnode = makeNode(CreatePolicyStmt); - - COPY_STRING_FIELD(policy_name); - COPY_NODE_FIELD(table); - COPY_STRING_FIELD(cmd_name); - COPY_SCALAR_FIELD(permissive); - COPY_NODE_FIELD(roles); - COPY_NODE_FIELD(qual); - COPY_NODE_FIELD(with_check); - - return newnode; -} - -static AlterPolicyStmt * -_copyAlterPolicyStmt(const AlterPolicyStmt *from) -{ - AlterPolicyStmt *newnode = makeNode(AlterPolicyStmt); - - COPY_STRING_FIELD(policy_name); - COPY_NODE_FIELD(table); - COPY_NODE_FIELD(roles); - COPY_NODE_FIELD(qual); - COPY_NODE_FIELD(with_check); - - return newnode; -} - -static PartitionElem * -_copyPartitionElem(const PartitionElem *from) -{ - PartitionElem *newnode = makeNode(PartitionElem); - - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(expr); - COPY_NODE_FIELD(collation); - COPY_NODE_FIELD(opclass); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static PartitionSpec * -_copyPartitionSpec(const PartitionSpec *from) -{ - PartitionSpec *newnode = makeNode(PartitionSpec); - - COPY_STRING_FIELD(strategy); - COPY_NODE_FIELD(partParams); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static PartitionBoundSpec * -_copyPartitionBoundSpec(const PartitionBoundSpec *from) -{ - PartitionBoundSpec *newnode = makeNode(PartitionBoundSpec); - - COPY_SCALAR_FIELD(strategy); - COPY_SCALAR_FIELD(is_default); - COPY_SCALAR_FIELD(modulus); - COPY_SCALAR_FIELD(remainder); - COPY_NODE_FIELD(listdatums); - COPY_NODE_FIELD(lowerdatums); - COPY_NODE_FIELD(upperdatums); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static PartitionRangeDatum * -_copyPartitionRangeDatum(const PartitionRangeDatum *from) -{ - PartitionRangeDatum *newnode = makeNode(PartitionRangeDatum); - - COPY_SCALAR_FIELD(kind); - COPY_NODE_FIELD(value); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static PartitionCmd * -_copyPartitionCmd(const PartitionCmd *from) -{ - PartitionCmd *newnode = makeNode(PartitionCmd); - - COPY_NODE_FIELD(name); - COPY_NODE_FIELD(bound); - COPY_SCALAR_FIELD(concurrent); - - return newnode; -} - -static PublicationObjSpec * -_copyPublicationObject(const PublicationObjSpec *from) -{ - PublicationObjSpec *newnode = makeNode(PublicationObjSpec); - - COPY_SCALAR_FIELD(pubobjtype); - COPY_STRING_FIELD(name); - COPY_NODE_FIELD(pubtable); - COPY_LOCATION_FIELD(location); - - return newnode; -} - -static PublicationTable * -_copyPublicationTable(const PublicationTable *from) -{ - PublicationTable *newnode = makeNode(PublicationTable); - - COPY_NODE_FIELD(relation); - COPY_NODE_FIELD(whereClause); - COPY_NODE_FIELD(columns); - - return newnode; -} - -static CreatePublicationStmt * -_copyCreatePublicationStmt(const CreatePublicationStmt *from) -{ - CreatePublicationStmt *newnode = makeNode(CreatePublicationStmt); - - COPY_STRING_FIELD(pubname); - COPY_NODE_FIELD(options); - COPY_NODE_FIELD(pubobjects); - COPY_SCALAR_FIELD(for_all_tables); - - return newnode; -} - -static AlterPublicationStmt * -_copyAlterPublicationStmt(const AlterPublicationStmt *from) -{ - AlterPublicationStmt *newnode = makeNode(AlterPublicationStmt); - - COPY_STRING_FIELD(pubname); - COPY_NODE_FIELD(options); - COPY_NODE_FIELD(pubobjects); - COPY_SCALAR_FIELD(for_all_tables); - COPY_SCALAR_FIELD(action); - - return newnode; -} - -static CreateSubscriptionStmt * -_copyCreateSubscriptionStmt(const CreateSubscriptionStmt *from) -{ - CreateSubscriptionStmt *newnode = makeNode(CreateSubscriptionStmt); - - COPY_STRING_FIELD(subname); - COPY_STRING_FIELD(conninfo); - COPY_NODE_FIELD(publication); - COPY_NODE_FIELD(options); - - return newnode; -} - -static AlterSubscriptionStmt * -_copyAlterSubscriptionStmt(const AlterSubscriptionStmt *from) -{ - AlterSubscriptionStmt *newnode = makeNode(AlterSubscriptionStmt); - - COPY_SCALAR_FIELD(kind); - COPY_STRING_FIELD(subname); - COPY_STRING_FIELD(conninfo); - COPY_NODE_FIELD(publication); - COPY_NODE_FIELD(options); - - return newnode; -} - -static DropSubscriptionStmt * -_copyDropSubscriptionStmt(const DropSubscriptionStmt *from) -{ - DropSubscriptionStmt *newnode = makeNode(DropSubscriptionStmt); - - COPY_STRING_FIELD(subname); - COPY_SCALAR_FIELD(missing_ok); - COPY_SCALAR_FIELD(behavior); - - return newnode; -} -#endif /* OBSOLETE */ - -/* **************************************************************** - * extensible.h copy functions - * **************************************************************** - */ static ExtensibleNode * _copyExtensibleNode(const ExtensibleNode *from) { @@ -5445,78 +160,6 @@ _copyExtensibleNode(const ExtensibleNode *from) return newnode; } -#ifdef OBSOLETE -/* **************************************************************** - * value.h copy functions - * **************************************************************** - */ -static Integer * -_copyInteger(const Integer *from) -{ - Integer *newnode = makeNode(Integer); - - COPY_SCALAR_FIELD(ival); - - return newnode; -} - -static Float * -_copyFloat(const Float *from) -{ - Float *newnode = makeNode(Float); - - COPY_STRING_FIELD(fval); - - return newnode; -} - -static Boolean * -_copyBoolean(const Boolean *from) -{ - Boolean *newnode = makeNode(Boolean); - - COPY_SCALAR_FIELD(boolval); - - return newnode; -} - -static String * -_copyString(const String *from) -{ - String *newnode = makeNode(String); - - COPY_STRING_FIELD(sval); - - return newnode; -} - -static BitString * -_copyBitString(const BitString *from) -{ - BitString *newnode = makeNode(BitString); - - COPY_STRING_FIELD(bsval); - - return newnode; -} - - -static ForeignKeyCacheInfo * -_copyForeignKeyCacheInfo(const ForeignKeyCacheInfo *from) -{ - ForeignKeyCacheInfo *newnode = makeNode(ForeignKeyCacheInfo); - - COPY_SCALAR_FIELD(conoid); - COPY_SCALAR_FIELD(conrelid); - COPY_SCALAR_FIELD(confrelid); - COPY_SCALAR_FIELD(nkeys); - COPY_ARRAY_FIELD(conkey); - COPY_ARRAY_FIELD(confkey); - COPY_ARRAY_FIELD(conpfeqop); - - return newnode; -} -#endif /* OBSOLETE */ /* * copyObjectImpl -- implementation of copyObject(); see nodes/nodes.h @@ -5538,450 +181,7 @@ copyObjectImpl(const void *from) switch (nodeTag(from)) { #include "copyfuncs.switch.c" -#ifdef OBSOLETE - /* - * PLAN NODES - */ - case T_PlannedStmt: - retval = _copyPlannedStmt(from); - break; - case T_Result: - retval = _copyResult(from); - break; - case T_ProjectSet: - retval = _copyProjectSet(from); - break; - case T_ModifyTable: - retval = _copyModifyTable(from); - break; - case T_Append: - retval = _copyAppend(from); - break; - case T_MergeAppend: - retval = _copyMergeAppend(from); - break; - case T_RecursiveUnion: - retval = _copyRecursiveUnion(from); - break; - case T_BitmapAnd: - retval = _copyBitmapAnd(from); - break; - case T_BitmapOr: - retval = _copyBitmapOr(from); - break; - case T_Scan: - retval = _copyScan(from); - break; - case T_Gather: - retval = _copyGather(from); - break; - case T_GatherMerge: - retval = _copyGatherMerge(from); - break; - case T_SeqScan: - retval = _copySeqScan(from); - break; - case T_SampleScan: - retval = _copySampleScan(from); - break; - case T_IndexScan: - retval = _copyIndexScan(from); - break; - case T_IndexOnlyScan: - retval = _copyIndexOnlyScan(from); - break; - case T_BitmapIndexScan: - retval = _copyBitmapIndexScan(from); - break; - case T_BitmapHeapScan: - retval = _copyBitmapHeapScan(from); - break; - case T_TidScan: - retval = _copyTidScan(from); - break; - case T_TidRangeScan: - retval = _copyTidRangeScan(from); - break; - case T_SubqueryScan: - retval = _copySubqueryScan(from); - break; - case T_FunctionScan: - retval = _copyFunctionScan(from); - break; - case T_TableFuncScan: - retval = _copyTableFuncScan(from); - break; - case T_ValuesScan: - retval = _copyValuesScan(from); - break; - case T_CteScan: - retval = _copyCteScan(from); - break; - case T_NamedTuplestoreScan: - retval = _copyNamedTuplestoreScan(from); - break; - case T_WorkTableScan: - retval = _copyWorkTableScan(from); - break; - case T_ForeignScan: - retval = _copyForeignScan(from); - break; - case T_CustomScan: - retval = _copyCustomScan(from); - break; - case T_NestLoop: - retval = _copyNestLoop(from); - break; - case T_MergeJoin: - retval = _copyMergeJoin(from); - break; - case T_HashJoin: - retval = _copyHashJoin(from); - break; - case T_Material: - retval = _copyMaterial(from); - break; - case T_Memoize: - retval = _copyMemoize(from); - break; - case T_Sort: - retval = _copySort(from); - break; - case T_IncrementalSort: - retval = _copyIncrementalSort(from); - break; - case T_Group: - retval = _copyGroup(from); - break; - case T_Agg: - retval = _copyAgg(from); - break; - case T_WindowAgg: - retval = _copyWindowAgg(from); - break; - case T_Unique: - retval = _copyUnique(from); - break; - case T_Hash: - retval = _copyHash(from); - break; - case T_SetOp: - retval = _copySetOp(from); - break; - case T_LockRows: - retval = _copyLockRows(from); - break; - case T_Limit: - retval = _copyLimit(from); - break; - case T_NestLoopParam: - retval = _copyNestLoopParam(from); - break; - case T_PlanRowMark: - retval = _copyPlanRowMark(from); - break; - case T_PartitionPruneInfo: - retval = _copyPartitionPruneInfo(from); - break; - case T_PartitionedRelPruneInfo: - retval = _copyPartitionedRelPruneInfo(from); - break; - case T_PartitionPruneStepOp: - retval = _copyPartitionPruneStepOp(from); - break; - case T_PartitionPruneStepCombine: - retval = _copyPartitionPruneStepCombine(from); - break; - case T_PlanInvalItem: - retval = _copyPlanInvalItem(from); - break; - /* - * PRIMITIVE NODES - */ - case T_Alias: - retval = _copyAlias(from); - break; - case T_RangeVar: - retval = _copyRangeVar(from); - break; - case T_TableFunc: - retval = _copyTableFunc(from); - break; - case T_IntoClause: - retval = _copyIntoClause(from); - break; - case T_Var: - retval = _copyVar(from); - break; - case T_Const: - retval = _copyConst(from); - break; - case T_Param: - retval = _copyParam(from); - break; - case T_Aggref: - retval = _copyAggref(from); - break; - case T_GroupingFunc: - retval = _copyGroupingFunc(from); - break; - case T_WindowFunc: - retval = _copyWindowFunc(from); - break; - case T_SubscriptingRef: - retval = _copySubscriptingRef(from); - break; - case T_FuncExpr: - retval = _copyFuncExpr(from); - break; - case T_NamedArgExpr: - retval = _copyNamedArgExpr(from); - break; - case T_OpExpr: - retval = _copyOpExpr(from); - break; - case T_DistinctExpr: - retval = _copyDistinctExpr(from); - break; - case T_NullIfExpr: - retval = _copyNullIfExpr(from); - break; - case T_ScalarArrayOpExpr: - retval = _copyScalarArrayOpExpr(from); - break; - case T_BoolExpr: - retval = _copyBoolExpr(from); - break; - case T_SubLink: - retval = _copySubLink(from); - break; - case T_SubPlan: - retval = _copySubPlan(from); - break; - case T_AlternativeSubPlan: - retval = _copyAlternativeSubPlan(from); - break; - case T_FieldSelect: - retval = _copyFieldSelect(from); - break; - case T_FieldStore: - retval = _copyFieldStore(from); - break; - case T_RelabelType: - retval = _copyRelabelType(from); - break; - case T_CoerceViaIO: - retval = _copyCoerceViaIO(from); - break; - case T_ArrayCoerceExpr: - retval = _copyArrayCoerceExpr(from); - break; - case T_ConvertRowtypeExpr: - retval = _copyConvertRowtypeExpr(from); - break; - case T_CollateExpr: - retval = _copyCollateExpr(from); - break; - case T_CaseExpr: - retval = _copyCaseExpr(from); - break; - case T_CaseWhen: - retval = _copyCaseWhen(from); - break; - case T_CaseTestExpr: - retval = _copyCaseTestExpr(from); - break; - case T_ArrayExpr: - retval = _copyArrayExpr(from); - break; - case T_RowExpr: - retval = _copyRowExpr(from); - break; - case T_RowCompareExpr: - retval = _copyRowCompareExpr(from); - break; - case T_CoalesceExpr: - retval = _copyCoalesceExpr(from); - break; - case T_MinMaxExpr: - retval = _copyMinMaxExpr(from); - break; - case T_SQLValueFunction: - retval = _copySQLValueFunction(from); - break; - case T_XmlExpr: - retval = _copyXmlExpr(from); - break; - case T_NullTest: - retval = _copyNullTest(from); - break; - case T_BooleanTest: - retval = _copyBooleanTest(from); - break; - case T_CoerceToDomain: - retval = _copyCoerceToDomain(from); - break; - case T_CoerceToDomainValue: - retval = _copyCoerceToDomainValue(from); - break; - case T_SetToDefault: - retval = _copySetToDefault(from); - break; - case T_CurrentOfExpr: - retval = _copyCurrentOfExpr(from); - break; - case T_NextValueExpr: - retval = _copyNextValueExpr(from); - break; - case T_InferenceElem: - retval = _copyInferenceElem(from); - break; - case T_TargetEntry: - retval = _copyTargetEntry(from); - break; - case T_RangeTblRef: - retval = _copyRangeTblRef(from); - break; - case T_JoinExpr: - retval = _copyJoinExpr(from); - break; - case T_FromExpr: - retval = _copyFromExpr(from); - break; - case T_OnConflictExpr: - retval = _copyOnConflictExpr(from); - break; - case T_JsonFormat: - retval = _copyJsonFormat(from); - break; - case T_JsonReturning: - retval = _copyJsonReturning(from); - break; - case T_JsonValueExpr: - retval = _copyJsonValueExpr(from); - break; - case T_JsonParseExpr: - retval = _copyJsonParseExpr(from); - break; - case T_JsonScalarExpr: - retval = _copyJsonScalarExpr(from); - break; - case T_JsonSerializeExpr: - retval = _copyJsonSerializeExpr(from); - break; - case T_JsonKeyValue: - retval = _copyJsonKeyValue(from); - break; - case T_JsonConstructorExpr: - retval = _copyJsonConstructorExpr(from); - break; - case T_JsonObjectConstructor: - retval = _copyJsonObjectConstructor(from); - break; - case T_JsonAggConstructor: - retval = _copyJsonAggConstructor(from); - break; - case T_JsonObjectAgg: - retval = _copyJsonObjectAgg(from); - break; - case T_JsonOutput: - retval = _copyJsonOutput(from); - break; - case T_JsonArrayConstructor: - retval = _copyJsonArrayConstructor(from); - break; - case T_JsonArrayQueryConstructor: - retval = _copyJsonArrayQueryConstructor(from); - break; - case T_JsonArrayAgg: - retval = _copyJsonArrayAgg(from); - break; - case T_JsonIsPredicate: - retval = _copyJsonIsPredicate(from); - break; - case T_JsonFuncExpr: - retval = _copyJsonFuncExpr(from); - break; - case T_JsonExpr: - retval = _copyJsonExpr(from); - break; - case T_JsonCommon: - retval = _copyJsonCommon(from); - break; - case T_JsonBehavior: - retval = _copyJsonBehavior(from); - break; - case T_JsonArgument: - retval = _copyJsonArgument(from); - break; - case T_JsonCoercion: - retval = _copyJsonCoercion(from); - break; - case T_JsonItemCoercions: - retval = _copyJsonItemCoercions(from); - break; - case T_JsonTable: - retval = _copyJsonTable(from); - break; - case T_JsonTableColumn: - retval = _copyJsonTableColumn(from); - break; - case T_JsonTablePlan: - retval = _copyJsonTablePlan(from); - break; - case T_JsonTableParent: - retval = _copyJsonTableParent(from); - break; - case T_JsonTableSibling: - retval = _copyJsonTableSibling(from); - break; - - /* - * RELATION NODES - */ - case T_PathKey: - retval = _copyPathKey(from); - break; - case T_RestrictInfo: - retval = _copyRestrictInfo(from); - break; - case T_PlaceHolderVar: - retval = _copyPlaceHolderVar(from); - break; - case T_SpecialJoinInfo: - retval = _copySpecialJoinInfo(from); - break; - case T_AppendRelInfo: - retval = _copyAppendRelInfo(from); - break; - case T_PlaceHolderInfo: - retval = _copyPlaceHolderInfo(from); - break; - - /* - * VALUE NODES - */ - case T_Integer: - retval = _copyInteger(from); - break; - case T_Float: - retval = _copyFloat(from); - break; - case T_Boolean: - retval = _copyBoolean(from); - break; - case T_String: - retval = _copyString(from); - break; - case T_BitString: - retval = _copyBitString(from); - break; -#endif /* OBSOLETE */ - - /* - * LIST NODES - */ case T_List: retval = list_copy_deep(from); break; @@ -5995,561 +195,6 @@ copyObjectImpl(const void *from) retval = list_copy(from); break; -#ifdef OBSOLETE - - /* - * EXTENSIBLE NODES - */ - case T_ExtensibleNode: - retval = _copyExtensibleNode(from); - break; - - /* - * PARSE NODES - */ - case T_Query: - retval = _copyQuery(from); - break; - case T_RawStmt: - retval = _copyRawStmt(from); - break; - case T_InsertStmt: - retval = _copyInsertStmt(from); - break; - case T_DeleteStmt: - retval = _copyDeleteStmt(from); - break; - case T_UpdateStmt: - retval = _copyUpdateStmt(from); - break; - case T_MergeStmt: - retval = _copyMergeStmt(from); - break; - case T_SelectStmt: - retval = _copySelectStmt(from); - break; - case T_SetOperationStmt: - retval = _copySetOperationStmt(from); - break; - case T_ReturnStmt: - retval = _copyReturnStmt(from); - break; - case T_PLAssignStmt: - retval = _copyPLAssignStmt(from); - break; - case T_AlterTableStmt: - retval = _copyAlterTableStmt(from); - break; - case T_AlterTableCmd: - retval = _copyAlterTableCmd(from); - break; - case T_AlterCollationStmt: - retval = _copyAlterCollationStmt(from); - break; - case T_AlterDomainStmt: - retval = _copyAlterDomainStmt(from); - break; - case T_GrantStmt: - retval = _copyGrantStmt(from); - break; - case T_GrantRoleStmt: - retval = _copyGrantRoleStmt(from); - break; - case T_AlterDefaultPrivilegesStmt: - retval = _copyAlterDefaultPrivilegesStmt(from); - break; - case T_DeclareCursorStmt: - retval = _copyDeclareCursorStmt(from); - break; - case T_ClosePortalStmt: - retval = _copyClosePortalStmt(from); - break; - case T_CallStmt: - retval = _copyCallStmt(from); - break; - case T_ClusterStmt: - retval = _copyClusterStmt(from); - break; - case T_CopyStmt: - retval = _copyCopyStmt(from); - break; - case T_CreateStmt: - retval = _copyCreateStmt(from); - break; - case T_TableLikeClause: - retval = _copyTableLikeClause(from); - break; - case T_DefineStmt: - retval = _copyDefineStmt(from); - break; - case T_DropStmt: - retval = _copyDropStmt(from); - break; - case T_TruncateStmt: - retval = _copyTruncateStmt(from); - break; - case T_CommentStmt: - retval = _copyCommentStmt(from); - break; - case T_SecLabelStmt: - retval = _copySecLabelStmt(from); - break; - case T_FetchStmt: - retval = _copyFetchStmt(from); - break; - case T_IndexStmt: - retval = _copyIndexStmt(from); - break; - case T_CreateStatsStmt: - retval = _copyCreateStatsStmt(from); - break; - case T_AlterStatsStmt: - retval = _copyAlterStatsStmt(from); - break; - case T_CreateFunctionStmt: - retval = _copyCreateFunctionStmt(from); - break; - case T_FunctionParameter: - retval = _copyFunctionParameter(from); - break; - case T_AlterFunctionStmt: - retval = _copyAlterFunctionStmt(from); - break; - case T_DoStmt: - retval = _copyDoStmt(from); - break; - case T_RenameStmt: - retval = _copyRenameStmt(from); - break; - case T_AlterObjectDependsStmt: - retval = _copyAlterObjectDependsStmt(from); - break; - case T_AlterObjectSchemaStmt: - retval = _copyAlterObjectSchemaStmt(from); - break; - case T_AlterOwnerStmt: - retval = _copyAlterOwnerStmt(from); - break; - case T_AlterOperatorStmt: - retval = _copyAlterOperatorStmt(from); - break; - case T_AlterTypeStmt: - retval = _copyAlterTypeStmt(from); - break; - case T_RuleStmt: - retval = _copyRuleStmt(from); - break; - case T_NotifyStmt: - retval = _copyNotifyStmt(from); - break; - case T_ListenStmt: - retval = _copyListenStmt(from); - break; - case T_UnlistenStmt: - retval = _copyUnlistenStmt(from); - break; - case T_TransactionStmt: - retval = _copyTransactionStmt(from); - break; - case T_CompositeTypeStmt: - retval = _copyCompositeTypeStmt(from); - break; - case T_CreateEnumStmt: - retval = _copyCreateEnumStmt(from); - break; - case T_CreateRangeStmt: - retval = _copyCreateRangeStmt(from); - break; - case T_AlterEnumStmt: - retval = _copyAlterEnumStmt(from); - break; - case T_ViewStmt: - retval = _copyViewStmt(from); - break; - case T_LoadStmt: - retval = _copyLoadStmt(from); - break; - case T_CreateDomainStmt: - retval = _copyCreateDomainStmt(from); - break; - case T_CreateOpClassStmt: - retval = _copyCreateOpClassStmt(from); - break; - case T_CreateOpClassItem: - retval = _copyCreateOpClassItem(from); - break; - case T_CreateOpFamilyStmt: - retval = _copyCreateOpFamilyStmt(from); - break; - case T_AlterOpFamilyStmt: - retval = _copyAlterOpFamilyStmt(from); - break; - case T_CreatedbStmt: - retval = _copyCreatedbStmt(from); - break; - case T_AlterDatabaseStmt: - retval = _copyAlterDatabaseStmt(from); - break; - case T_AlterDatabaseRefreshCollStmt: - retval = _copyAlterDatabaseRefreshCollStmt(from); - break; - case T_AlterDatabaseSetStmt: - retval = _copyAlterDatabaseSetStmt(from); - break; - case T_DropdbStmt: - retval = _copyDropdbStmt(from); - break; - case T_VacuumStmt: - retval = _copyVacuumStmt(from); - break; - case T_VacuumRelation: - retval = _copyVacuumRelation(from); - break; - case T_ExplainStmt: - retval = _copyExplainStmt(from); - break; - case T_CreateTableAsStmt: - retval = _copyCreateTableAsStmt(from); - break; - case T_RefreshMatViewStmt: - retval = _copyRefreshMatViewStmt(from); - break; - case T_ReplicaIdentityStmt: - retval = _copyReplicaIdentityStmt(from); - break; - case T_AlterSystemStmt: - retval = _copyAlterSystemStmt(from); - break; - case T_CreateSeqStmt: - retval = _copyCreateSeqStmt(from); - break; - case T_AlterSeqStmt: - retval = _copyAlterSeqStmt(from); - break; - case T_VariableSetStmt: - retval = _copyVariableSetStmt(from); - break; - case T_VariableShowStmt: - retval = _copyVariableShowStmt(from); - break; - case T_DiscardStmt: - retval = _copyDiscardStmt(from); - break; - case T_CreateTableSpaceStmt: - retval = _copyCreateTableSpaceStmt(from); - break; - case T_DropTableSpaceStmt: - retval = _copyDropTableSpaceStmt(from); - break; - case T_AlterTableSpaceOptionsStmt: - retval = _copyAlterTableSpaceOptionsStmt(from); - break; - case T_AlterTableMoveAllStmt: - retval = _copyAlterTableMoveAllStmt(from); - break; - case T_CreateExtensionStmt: - retval = _copyCreateExtensionStmt(from); - break; - case T_AlterExtensionStmt: - retval = _copyAlterExtensionStmt(from); - break; - case T_AlterExtensionContentsStmt: - retval = _copyAlterExtensionContentsStmt(from); - break; - case T_CreateFdwStmt: - retval = _copyCreateFdwStmt(from); - break; - case T_AlterFdwStmt: - retval = _copyAlterFdwStmt(from); - break; - case T_CreateForeignServerStmt: - retval = _copyCreateForeignServerStmt(from); - break; - case T_AlterForeignServerStmt: - retval = _copyAlterForeignServerStmt(from); - break; - case T_CreateUserMappingStmt: - retval = _copyCreateUserMappingStmt(from); - break; - case T_AlterUserMappingStmt: - retval = _copyAlterUserMappingStmt(from); - break; - case T_DropUserMappingStmt: - retval = _copyDropUserMappingStmt(from); - break; - case T_CreateForeignTableStmt: - retval = _copyCreateForeignTableStmt(from); - break; - case T_ImportForeignSchemaStmt: - retval = _copyImportForeignSchemaStmt(from); - break; - case T_CreateTransformStmt: - retval = _copyCreateTransformStmt(from); - break; - case T_CreateAmStmt: - retval = _copyCreateAmStmt(from); - break; - case T_CreateTrigStmt: - retval = _copyCreateTrigStmt(from); - break; - case T_CreateEventTrigStmt: - retval = _copyCreateEventTrigStmt(from); - break; - case T_AlterEventTrigStmt: - retval = _copyAlterEventTrigStmt(from); - break; - case T_CreatePLangStmt: - retval = _copyCreatePLangStmt(from); - break; - case T_CreateRoleStmt: - retval = _copyCreateRoleStmt(from); - break; - case T_AlterRoleStmt: - retval = _copyAlterRoleStmt(from); - break; - case T_AlterRoleSetStmt: - retval = _copyAlterRoleSetStmt(from); - break; - case T_DropRoleStmt: - retval = _copyDropRoleStmt(from); - break; - case T_LockStmt: - retval = _copyLockStmt(from); - break; - case T_ConstraintsSetStmt: - retval = _copyConstraintsSetStmt(from); - break; - case T_ReindexStmt: - retval = _copyReindexStmt(from); - break; - case T_CheckPointStmt: - retval = (void *) makeNode(CheckPointStmt); - break; - case T_CreateSchemaStmt: - retval = _copyCreateSchemaStmt(from); - break; - case T_CreateConversionStmt: - retval = _copyCreateConversionStmt(from); - break; - case T_CreateCastStmt: - retval = _copyCreateCastStmt(from); - break; - case T_PrepareStmt: - retval = _copyPrepareStmt(from); - break; - case T_ExecuteStmt: - retval = _copyExecuteStmt(from); - break; - case T_DeallocateStmt: - retval = _copyDeallocateStmt(from); - break; - case T_DropOwnedStmt: - retval = _copyDropOwnedStmt(from); - break; - case T_ReassignOwnedStmt: - retval = _copyReassignOwnedStmt(from); - break; - case T_AlterTSDictionaryStmt: - retval = _copyAlterTSDictionaryStmt(from); - break; - case T_AlterTSConfigurationStmt: - retval = _copyAlterTSConfigurationStmt(from); - break; - case T_CreatePolicyStmt: - retval = _copyCreatePolicyStmt(from); - break; - case T_AlterPolicyStmt: - retval = _copyAlterPolicyStmt(from); - break; - case T_CreatePublicationStmt: - retval = _copyCreatePublicationStmt(from); - break; - case T_AlterPublicationStmt: - retval = _copyAlterPublicationStmt(from); - break; - case T_CreateSubscriptionStmt: - retval = _copyCreateSubscriptionStmt(from); - break; - case T_AlterSubscriptionStmt: - retval = _copyAlterSubscriptionStmt(from); - break; - case T_DropSubscriptionStmt: - retval = _copyDropSubscriptionStmt(from); - break; - case T_A_Expr: - retval = _copyA_Expr(from); - break; - case T_ColumnRef: - retval = _copyColumnRef(from); - break; - case T_ParamRef: - retval = _copyParamRef(from); - break; - case T_A_Const: - retval = _copyA_Const(from); - break; - case T_FuncCall: - retval = _copyFuncCall(from); - break; - case T_A_Star: - retval = _copyA_Star(from); - break; - case T_A_Indices: - retval = _copyA_Indices(from); - break; - case T_A_Indirection: - retval = _copyA_Indirection(from); - break; - case T_A_ArrayExpr: - retval = _copyA_ArrayExpr(from); - break; - case T_ResTarget: - retval = _copyResTarget(from); - break; - case T_MultiAssignRef: - retval = _copyMultiAssignRef(from); - break; - case T_TypeCast: - retval = _copyTypeCast(from); - break; - case T_CollateClause: - retval = _copyCollateClause(from); - break; - case T_SortBy: - retval = _copySortBy(from); - break; - case T_WindowDef: - retval = _copyWindowDef(from); - break; - case T_RangeSubselect: - retval = _copyRangeSubselect(from); - break; - case T_RangeFunction: - retval = _copyRangeFunction(from); - break; - case T_RangeTableSample: - retval = _copyRangeTableSample(from); - break; - case T_RangeTableFunc: - retval = _copyRangeTableFunc(from); - break; - case T_RangeTableFuncCol: - retval = _copyRangeTableFuncCol(from); - break; - case T_TypeName: - retval = _copyTypeName(from); - break; - case T_IndexElem: - retval = _copyIndexElem(from); - break; - case T_StatsElem: - retval = _copyStatsElem(from); - break; - case T_ColumnDef: - retval = _copyColumnDef(from); - break; - case T_Constraint: - retval = _copyConstraint(from); - break; - case T_DefElem: - retval = _copyDefElem(from); - break; - case T_LockingClause: - retval = _copyLockingClause(from); - break; - case T_RangeTblEntry: - retval = _copyRangeTblEntry(from); - break; - case T_RangeTblFunction: - retval = _copyRangeTblFunction(from); - break; - case T_TableSampleClause: - retval = _copyTableSampleClause(from); - break; - case T_WithCheckOption: - retval = _copyWithCheckOption(from); - break; - case T_SortGroupClause: - retval = _copySortGroupClause(from); - break; - case T_GroupingSet: - retval = _copyGroupingSet(from); - break; - case T_WindowClause: - retval = _copyWindowClause(from); - break; - case T_RowMarkClause: - retval = _copyRowMarkClause(from); - break; - case T_WithClause: - retval = _copyWithClause(from); - break; - case T_InferClause: - retval = _copyInferClause(from); - break; - case T_OnConflictClause: - retval = _copyOnConflictClause(from); - break; - case T_CTESearchClause: - retval = _copyCTESearchClause(from); - break; - case T_CTECycleClause: - retval = _copyCTECycleClause(from); - break; - case T_CommonTableExpr: - retval = _copyCommonTableExpr(from); - break; - case T_MergeWhenClause: - retval = _copyMergeWhenClause(from); - break; - case T_MergeAction: - retval = _copyMergeAction(from); - break; - case T_ObjectWithArgs: - retval = _copyObjectWithArgs(from); - break; - case T_AccessPriv: - retval = _copyAccessPriv(from); - break; - case T_XmlSerialize: - retval = _copyXmlSerialize(from); - break; - case T_RoleSpec: - retval = _copyRoleSpec(from); - break; - case T_TriggerTransition: - retval = _copyTriggerTransition(from); - break; - case T_PartitionElem: - retval = _copyPartitionElem(from); - break; - case T_PartitionSpec: - retval = _copyPartitionSpec(from); - break; - case T_PartitionBoundSpec: - retval = _copyPartitionBoundSpec(from); - break; - case T_PartitionRangeDatum: - retval = _copyPartitionRangeDatum(from); - break; - case T_PartitionCmd: - retval = _copyPartitionCmd(from); - break; - case T_PublicationObjSpec: - retval = _copyPublicationObject(from); - break; - case T_PublicationTable: - retval = _copyPublicationTable(from); - break; - - /* - * MISCELLANEOUS NODES - */ - case T_ForeignKeyCacheInfo: - retval = _copyForeignKeyCacheInfo(from); - break; -#endif /* OBSOLETE */ - default: elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from)); retval = 0; /* keep compiler quiet */ diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c index 8d18548ade..8d54e1a486 100644 --- a/src/backend/nodes/equalfuncs.c +++ b/src/backend/nodes/equalfuncs.c @@ -3,13 +3,6 @@ * equalfuncs.c * Equality functions to compare node trees. * - * NOTE: we currently support comparing all node types found in parse - * trees. We do not support comparing executor state trees; there - * is no need for that, and no point in maintaining all the code that - * would be needed. We also do not support comparing Path trees, mainly - * because the circular linkages between RelOptInfo and Path nodes can't - * be handled easily in a simple depth-first traversal. - * * NOTE: it is intentional that parse location fields (in nodes that have * one) are not compared. This is because we want, for example, a variable * "x" to be considered equal() to another reference to "x" in the query. @@ -94,170 +87,11 @@ #include "equalfuncs.funcs.c" -#ifdef OBSOLETE -/* - * Stuff from primnodes.h - */ - -static bool -_equalAlias(const Alias *a, const Alias *b) -{ - COMPARE_STRING_FIELD(aliasname); - COMPARE_NODE_FIELD(colnames); - - return true; -} - -static bool -_equalRangeVar(const RangeVar *a, const RangeVar *b) -{ - COMPARE_STRING_FIELD(catalogname); - COMPARE_STRING_FIELD(schemaname); - COMPARE_STRING_FIELD(relname); - COMPARE_SCALAR_FIELD(inh); - COMPARE_SCALAR_FIELD(relpersistence); - COMPARE_NODE_FIELD(alias); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -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); - COMPARE_NODE_FIELD(rowexpr); - COMPARE_NODE_FIELD(colnames); - COMPARE_NODE_FIELD(coltypes); - COMPARE_NODE_FIELD(coltypmods); - COMPARE_NODE_FIELD(colcollations); - COMPARE_NODE_FIELD(colexprs); - COMPARE_NODE_FIELD(coldefexprs); - COMPARE_NODE_FIELD(colvalexprs); - COMPARE_BITMAPSET_FIELD(notnulls); - COMPARE_NODE_FIELD(plan); - COMPARE_SCALAR_FIELD(ordinalitycol); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonTablePlan(const JsonTablePlan *a, const JsonTablePlan *b) -{ - COMPARE_SCALAR_FIELD(plan_type); - COMPARE_SCALAR_FIELD(join_type); - COMPARE_NODE_FIELD(plan1); - COMPARE_NODE_FIELD(plan2); - COMPARE_STRING_FIELD(pathname); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonTable(const JsonTable *a, const JsonTable *b) -{ - COMPARE_NODE_FIELD(common); - COMPARE_NODE_FIELD(columns); - COMPARE_NODE_FIELD(plan); - 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_STRING_FIELD(pathspec); - COMPARE_STRING_FIELD(pathname); - COMPARE_NODE_FIELD(format); - COMPARE_SCALAR_FIELD(wrapper); - COMPARE_SCALAR_FIELD(omit_quotes); - COMPARE_NODE_FIELD(columns); - COMPARE_NODE_FIELD(on_empty); - COMPARE_NODE_FIELD(on_error); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonTableParent(const JsonTableParent *a, const JsonTableParent *b) -{ - COMPARE_NODE_FIELD(path); - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(child); - COMPARE_SCALAR_FIELD(outerJoin); - COMPARE_SCALAR_FIELD(colMin); - COMPARE_SCALAR_FIELD(colMax); - COMPARE_SCALAR_FIELD(errorOnError); - - return true; -} - -static bool -_equalJsonTableSibling(const JsonTableSibling *a, const JsonTableSibling *b) -{ - COMPARE_NODE_FIELD(larg); - COMPARE_NODE_FIELD(rarg); - COMPARE_SCALAR_FIELD(cross); - - return true; -} - -static bool -_equalIntoClause(const IntoClause *a, const IntoClause *b) -{ - COMPARE_NODE_FIELD(rel); - COMPARE_NODE_FIELD(colNames); - COMPARE_STRING_FIELD(accessMethod); - COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(onCommit); - COMPARE_STRING_FIELD(tableSpaceName); - COMPARE_NODE_FIELD(viewQuery); - COMPARE_SCALAR_FIELD(skipData); - - return true; -} /* - * We don't need an _equalExpr because Expr is an abstract supertype which - * should never actually get instantiated. Also, since it has no common - * fields except NodeTag, there's no need for a helper routine to factor - * out comparing the common fields... + * Support functions for nodes with custom_copy_equal attribute */ -static bool -_equalVar(const Var *a, const Var *b) -{ - COMPARE_SCALAR_FIELD(varno); - COMPARE_SCALAR_FIELD(varattno); - COMPARE_SCALAR_FIELD(vartype); - COMPARE_SCALAR_FIELD(vartypmod); - COMPARE_SCALAR_FIELD(varcollid); - COMPARE_SCALAR_FIELD(varlevelsup); - - /* - * varnosyn/varattnosyn are intentionally ignored here, because Vars with - * different syntactic identifiers are semantically the same as long as - * their varno/varattno match. - */ - COMPARE_LOCATION_FIELD(location); - - return true; -} -#endif /* OBSOLETE */ - static bool _equalConst(const Const *a, const Const *b) { @@ -279,1036 +113,6 @@ _equalConst(const Const *a, const Const *b) a->constbyval, a->constlen); } -#ifdef OBSOLETE -static bool -_equalParam(const Param *a, const Param *b) -{ - COMPARE_SCALAR_FIELD(paramkind); - COMPARE_SCALAR_FIELD(paramid); - COMPARE_SCALAR_FIELD(paramtype); - COMPARE_SCALAR_FIELD(paramtypmod); - COMPARE_SCALAR_FIELD(paramcollid); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalAggref(const Aggref *a, const Aggref *b) -{ - COMPARE_SCALAR_FIELD(aggfnoid); - COMPARE_SCALAR_FIELD(aggtype); - COMPARE_SCALAR_FIELD(aggcollid); - COMPARE_SCALAR_FIELD(inputcollid); - /* ignore aggtranstype since it might not be set yet */ - COMPARE_NODE_FIELD(aggargtypes); - COMPARE_NODE_FIELD(aggdirectargs); - COMPARE_NODE_FIELD(args); - COMPARE_NODE_FIELD(aggorder); - COMPARE_NODE_FIELD(aggdistinct); - COMPARE_NODE_FIELD(aggfilter); - COMPARE_SCALAR_FIELD(aggstar); - COMPARE_SCALAR_FIELD(aggvariadic); - COMPARE_SCALAR_FIELD(aggkind); - COMPARE_SCALAR_FIELD(agglevelsup); - COMPARE_SCALAR_FIELD(aggsplit); - COMPARE_SCALAR_FIELD(aggno); - COMPARE_SCALAR_FIELD(aggtransno); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalGroupingFunc(const GroupingFunc *a, const GroupingFunc *b) -{ - COMPARE_NODE_FIELD(args); - - /* - * We must not compare the refs or cols field - */ - - COMPARE_SCALAR_FIELD(agglevelsup); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalWindowFunc(const WindowFunc *a, const WindowFunc *b) -{ - COMPARE_SCALAR_FIELD(winfnoid); - COMPARE_SCALAR_FIELD(wintype); - COMPARE_SCALAR_FIELD(wincollid); - COMPARE_SCALAR_FIELD(inputcollid); - COMPARE_NODE_FIELD(args); - COMPARE_NODE_FIELD(aggfilter); - COMPARE_SCALAR_FIELD(winref); - COMPARE_SCALAR_FIELD(winstar); - COMPARE_SCALAR_FIELD(winagg); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalSubscriptingRef(const SubscriptingRef *a, const SubscriptingRef *b) -{ - COMPARE_SCALAR_FIELD(refcontainertype); - COMPARE_SCALAR_FIELD(refelemtype); - COMPARE_SCALAR_FIELD(refrestype); - COMPARE_SCALAR_FIELD(reftypmod); - COMPARE_SCALAR_FIELD(refcollid); - COMPARE_NODE_FIELD(refupperindexpr); - COMPARE_NODE_FIELD(reflowerindexpr); - COMPARE_NODE_FIELD(refexpr); - COMPARE_NODE_FIELD(refassgnexpr); - - return true; -} - -static bool -_equalFuncExpr(const FuncExpr *a, const FuncExpr *b) -{ - COMPARE_SCALAR_FIELD(funcid); - COMPARE_SCALAR_FIELD(funcresulttype); - COMPARE_SCALAR_FIELD(funcretset); - COMPARE_SCALAR_FIELD(funcvariadic); - COMPARE_COERCIONFORM_FIELD(funcformat); - COMPARE_SCALAR_FIELD(funccollid); - COMPARE_SCALAR_FIELD(inputcollid); - COMPARE_NODE_FIELD(args); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_STRING_FIELD(name); - COMPARE_SCALAR_FIELD(argnumber); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalOpExpr(const OpExpr *a, const OpExpr *b) -{ - COMPARE_SCALAR_FIELD(opno); - - /* - * Special-case opfuncid: it is allowable for it to differ if one node - * contains zero and the other doesn't. This just means that the one node - * isn't as far along in the parse/plan pipeline and hasn't had the - * opfuncid cache filled yet. - */ - if (a->opfuncid != b->opfuncid && - a->opfuncid != 0 && - b->opfuncid != 0) - return false; - - COMPARE_SCALAR_FIELD(opresulttype); - COMPARE_SCALAR_FIELD(opretset); - COMPARE_SCALAR_FIELD(opcollid); - COMPARE_SCALAR_FIELD(inputcollid); - COMPARE_NODE_FIELD(args); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b) -{ - COMPARE_SCALAR_FIELD(opno); - - /* - * Special-case opfuncid: it is allowable for it to differ if one node - * contains zero and the other doesn't. This just means that the one node - * isn't as far along in the parse/plan pipeline and hasn't had the - * opfuncid cache filled yet. - */ - if (a->opfuncid != b->opfuncid && - a->opfuncid != 0 && - b->opfuncid != 0) - return false; - - COMPARE_SCALAR_FIELD(opresulttype); - COMPARE_SCALAR_FIELD(opretset); - COMPARE_SCALAR_FIELD(opcollid); - COMPARE_SCALAR_FIELD(inputcollid); - COMPARE_NODE_FIELD(args); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalNullIfExpr(const NullIfExpr *a, const NullIfExpr *b) -{ - COMPARE_SCALAR_FIELD(opno); - - /* - * Special-case opfuncid: it is allowable for it to differ if one node - * contains zero and the other doesn't. This just means that the one node - * isn't as far along in the parse/plan pipeline and hasn't had the - * opfuncid cache filled yet. - */ - if (a->opfuncid != b->opfuncid && - a->opfuncid != 0 && - b->opfuncid != 0) - return false; - - COMPARE_SCALAR_FIELD(opresulttype); - COMPARE_SCALAR_FIELD(opretset); - COMPARE_SCALAR_FIELD(opcollid); - COMPARE_SCALAR_FIELD(inputcollid); - COMPARE_NODE_FIELD(args); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b) -{ - COMPARE_SCALAR_FIELD(opno); - - /* - * Special-case opfuncid: it is allowable for it to differ if one node - * contains zero and the other doesn't. This just means that the one node - * isn't as far along in the parse/plan pipeline and hasn't had the - * opfuncid cache filled yet. - */ - if (a->opfuncid != b->opfuncid && - a->opfuncid != 0 && - b->opfuncid != 0) - return false; - - /* As above, hashfuncid may differ too */ - if (a->hashfuncid != b->hashfuncid && - a->hashfuncid != 0 && - b->hashfuncid != 0) - return false; - - /* Likewise for the negfuncid */ - if (a->negfuncid != b->negfuncid && - a->negfuncid != 0 && - b->negfuncid != 0) - return false; - - COMPARE_SCALAR_FIELD(useOr); - COMPARE_SCALAR_FIELD(inputcollid); - COMPARE_NODE_FIELD(args); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalBoolExpr(const BoolExpr *a, const BoolExpr *b) -{ - COMPARE_SCALAR_FIELD(boolop); - COMPARE_NODE_FIELD(args); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalSubLink(const SubLink *a, const SubLink *b) -{ - COMPARE_SCALAR_FIELD(subLinkType); - COMPARE_SCALAR_FIELD(subLinkId); - COMPARE_NODE_FIELD(testexpr); - COMPARE_NODE_FIELD(operName); - COMPARE_NODE_FIELD(subselect); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalSubPlan(const SubPlan *a, const SubPlan *b) -{ - COMPARE_SCALAR_FIELD(subLinkType); - COMPARE_NODE_FIELD(testexpr); - COMPARE_NODE_FIELD(paramIds); - COMPARE_SCALAR_FIELD(plan_id); - COMPARE_STRING_FIELD(plan_name); - COMPARE_SCALAR_FIELD(firstColType); - COMPARE_SCALAR_FIELD(firstColTypmod); - COMPARE_SCALAR_FIELD(firstColCollation); - COMPARE_SCALAR_FIELD(useHashTable); - COMPARE_SCALAR_FIELD(unknownEqFalse); - COMPARE_SCALAR_FIELD(parallel_safe); - COMPARE_NODE_FIELD(setParam); - COMPARE_NODE_FIELD(parParam); - COMPARE_NODE_FIELD(args); - COMPARE_SCALAR_FIELD(startup_cost); - COMPARE_SCALAR_FIELD(per_call_cost); - - return true; -} - -static bool -_equalAlternativeSubPlan(const AlternativeSubPlan *a, const AlternativeSubPlan *b) -{ - COMPARE_NODE_FIELD(subplans); - - return true; -} - -static bool -_equalFieldSelect(const FieldSelect *a, const FieldSelect *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(fieldnum); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_SCALAR_FIELD(resulttypmod); - COMPARE_SCALAR_FIELD(resultcollid); - - return true; -} - -static bool -_equalFieldStore(const FieldStore *a, const FieldStore *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_NODE_FIELD(newvals); - COMPARE_NODE_FIELD(fieldnums); - COMPARE_SCALAR_FIELD(resulttype); - - return true; -} - -static bool -_equalRelabelType(const RelabelType *a, const RelabelType *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_SCALAR_FIELD(resulttypmod); - COMPARE_SCALAR_FIELD(resultcollid); - COMPARE_COERCIONFORM_FIELD(relabelformat); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCoerceViaIO(const CoerceViaIO *a, const CoerceViaIO *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_SCALAR_FIELD(resultcollid); - COMPARE_COERCIONFORM_FIELD(coerceformat); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalArrayCoerceExpr(const ArrayCoerceExpr *a, const ArrayCoerceExpr *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_NODE_FIELD(elemexpr); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_SCALAR_FIELD(resulttypmod); - COMPARE_SCALAR_FIELD(resultcollid); - COMPARE_COERCIONFORM_FIELD(coerceformat); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalConvertRowtypeExpr(const ConvertRowtypeExpr *a, const ConvertRowtypeExpr *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_COERCIONFORM_FIELD(convertformat); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCollateExpr(const CollateExpr *a, const CollateExpr *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(collOid); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCaseExpr(const CaseExpr *a, const CaseExpr *b) -{ - COMPARE_SCALAR_FIELD(casetype); - COMPARE_SCALAR_FIELD(casecollid); - COMPARE_NODE_FIELD(arg); - COMPARE_NODE_FIELD(args); - COMPARE_NODE_FIELD(defresult); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCaseWhen(const CaseWhen *a, const CaseWhen *b) -{ - COMPARE_NODE_FIELD(expr); - COMPARE_NODE_FIELD(result); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b) -{ - COMPARE_SCALAR_FIELD(typeId); - COMPARE_SCALAR_FIELD(typeMod); - COMPARE_SCALAR_FIELD(collation); - - return true; -} - -static bool -_equalArrayExpr(const ArrayExpr *a, const ArrayExpr *b) -{ - COMPARE_SCALAR_FIELD(array_typeid); - COMPARE_SCALAR_FIELD(array_collid); - COMPARE_SCALAR_FIELD(element_typeid); - COMPARE_NODE_FIELD(elements); - COMPARE_SCALAR_FIELD(multidims); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalRowExpr(const RowExpr *a, const RowExpr *b) -{ - COMPARE_NODE_FIELD(args); - COMPARE_SCALAR_FIELD(row_typeid); - COMPARE_COERCIONFORM_FIELD(row_format); - COMPARE_NODE_FIELD(colnames); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalRowCompareExpr(const RowCompareExpr *a, const RowCompareExpr *b) -{ - COMPARE_SCALAR_FIELD(rctype); - COMPARE_NODE_FIELD(opnos); - COMPARE_NODE_FIELD(opfamilies); - COMPARE_NODE_FIELD(inputcollids); - COMPARE_NODE_FIELD(largs); - COMPARE_NODE_FIELD(rargs); - - return true; -} - -static bool -_equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b) -{ - COMPARE_SCALAR_FIELD(coalescetype); - COMPARE_SCALAR_FIELD(coalescecollid); - COMPARE_NODE_FIELD(args); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b) -{ - COMPARE_SCALAR_FIELD(minmaxtype); - COMPARE_SCALAR_FIELD(minmaxcollid); - COMPARE_SCALAR_FIELD(inputcollid); - COMPARE_SCALAR_FIELD(op); - COMPARE_NODE_FIELD(args); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalSQLValueFunction(const SQLValueFunction *a, const SQLValueFunction *b) -{ - COMPARE_SCALAR_FIELD(op); - COMPARE_SCALAR_FIELD(type); - COMPARE_SCALAR_FIELD(typmod); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalXmlExpr(const XmlExpr *a, const XmlExpr *b) -{ - COMPARE_SCALAR_FIELD(op); - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(named_args); - COMPARE_NODE_FIELD(arg_names); - COMPARE_NODE_FIELD(args); - COMPARE_SCALAR_FIELD(xmloption); - COMPARE_SCALAR_FIELD(type); - COMPARE_SCALAR_FIELD(typmod); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalNullTest(const NullTest *a, const NullTest *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(nulltesttype); - COMPARE_SCALAR_FIELD(argisrow); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalBooleanTest(const BooleanTest *a, const BooleanTest *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(booltesttype); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(resulttype); - COMPARE_SCALAR_FIELD(resulttypmod); - COMPARE_SCALAR_FIELD(resultcollid); - COMPARE_COERCIONFORM_FIELD(coercionformat); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCoerceToDomainValue(const CoerceToDomainValue *a, const CoerceToDomainValue *b) -{ - COMPARE_SCALAR_FIELD(typeId); - COMPARE_SCALAR_FIELD(typeMod); - COMPARE_SCALAR_FIELD(collation); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalSetToDefault(const SetToDefault *a, const SetToDefault *b) -{ - COMPARE_SCALAR_FIELD(typeId); - COMPARE_SCALAR_FIELD(typeMod); - COMPARE_SCALAR_FIELD(collation); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCurrentOfExpr(const CurrentOfExpr *a, const CurrentOfExpr *b) -{ - COMPARE_SCALAR_FIELD(cvarno); - COMPARE_STRING_FIELD(cursor_name); - COMPARE_SCALAR_FIELD(cursor_param); - - return true; -} - -static bool -_equalNextValueExpr(const NextValueExpr *a, const NextValueExpr *b) -{ - COMPARE_SCALAR_FIELD(seqid); - COMPARE_SCALAR_FIELD(typeId); - - return true; -} - -static bool -_equalInferenceElem(const InferenceElem *a, const InferenceElem *b) -{ - COMPARE_NODE_FIELD(expr); - COMPARE_SCALAR_FIELD(infercollid); - COMPARE_SCALAR_FIELD(inferopclass); - - return true; -} - -static bool -_equalTargetEntry(const TargetEntry *a, const TargetEntry *b) -{ - COMPARE_NODE_FIELD(expr); - COMPARE_SCALAR_FIELD(resno); - COMPARE_STRING_FIELD(resname); - COMPARE_SCALAR_FIELD(ressortgroupref); - COMPARE_SCALAR_FIELD(resorigtbl); - COMPARE_SCALAR_FIELD(resorigcol); - COMPARE_SCALAR_FIELD(resjunk); - - return true; -} - -static bool -_equalRangeTblRef(const RangeTblRef *a, const RangeTblRef *b) -{ - COMPARE_SCALAR_FIELD(rtindex); - - return true; -} - -static bool -_equalJoinExpr(const JoinExpr *a, const JoinExpr *b) -{ - COMPARE_SCALAR_FIELD(jointype); - COMPARE_SCALAR_FIELD(isNatural); - COMPARE_NODE_FIELD(larg); - COMPARE_NODE_FIELD(rarg); - COMPARE_NODE_FIELD(usingClause); - COMPARE_NODE_FIELD(join_using_alias); - COMPARE_NODE_FIELD(quals); - COMPARE_NODE_FIELD(alias); - COMPARE_SCALAR_FIELD(rtindex); - - return true; -} - -static bool -_equalFromExpr(const FromExpr *a, const FromExpr *b) -{ - COMPARE_NODE_FIELD(fromlist); - COMPARE_NODE_FIELD(quals); - - return true; -} - -static bool -_equalOnConflictExpr(const OnConflictExpr *a, const OnConflictExpr *b) -{ - COMPARE_SCALAR_FIELD(action); - COMPARE_NODE_FIELD(arbiterElems); - COMPARE_NODE_FIELD(arbiterWhere); - COMPARE_SCALAR_FIELD(constraint); - COMPARE_NODE_FIELD(onConflictSet); - COMPARE_NODE_FIELD(onConflictWhere); - COMPARE_SCALAR_FIELD(exclRelIndex); - COMPARE_NODE_FIELD(exclRelTlist); - - return true; -} - -static bool -_equalJsonFormat(const JsonFormat *a, const JsonFormat *b) -{ - COMPARE_SCALAR_FIELD(format_type); - COMPARE_SCALAR_FIELD(encoding); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonReturning(const JsonReturning *a, const JsonReturning *b) -{ - COMPARE_NODE_FIELD(format); - COMPARE_SCALAR_FIELD(typid); - COMPARE_SCALAR_FIELD(typmod); - - return true; -} - -static bool -_equalJsonValueExpr(const JsonValueExpr *a, const JsonValueExpr *b) -{ - COMPARE_NODE_FIELD(raw_expr); - COMPARE_NODE_FIELD(formatted_expr); - COMPARE_NODE_FIELD(format); - - 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 -_equalJsonConstructorExpr(const JsonConstructorExpr *a, const JsonConstructorExpr *b) -{ - COMPARE_SCALAR_FIELD(type); - COMPARE_NODE_FIELD(args); - COMPARE_NODE_FIELD(func); - COMPARE_NODE_FIELD(coercion); - COMPARE_NODE_FIELD(returning); - COMPARE_SCALAR_FIELD(absent_on_null); - COMPARE_SCALAR_FIELD(unique); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonKeyValue(const JsonKeyValue *a, const JsonKeyValue *b) -{ - COMPARE_NODE_FIELD(key); - COMPARE_NODE_FIELD(value); - - return true; -} - -static bool -_equalJsonObjectConstructor(const JsonObjectConstructor *a, - const JsonObjectConstructor *b) -{ - COMPARE_NODE_FIELD(exprs); - COMPARE_NODE_FIELD(output); - COMPARE_SCALAR_FIELD(absent_on_null); - COMPARE_SCALAR_FIELD(unique); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonAggConstructor(const JsonAggConstructor *a, - const JsonAggConstructor *b) -{ - COMPARE_NODE_FIELD(output); - COMPARE_NODE_FIELD(agg_filter); - COMPARE_NODE_FIELD(agg_order); - COMPARE_NODE_FIELD(over); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonObjectAgg(const JsonObjectAgg *a, const JsonObjectAgg *b) -{ - COMPARE_NODE_FIELD(constructor); - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(absent_on_null); - COMPARE_SCALAR_FIELD(unique); - - return true; -} - -static bool -_equalJsonOutput(const JsonOutput *a, const JsonOutput *b) -{ - COMPARE_NODE_FIELD(typeName); - COMPARE_NODE_FIELD(returning); - - return true; -} - -static bool -_equalJsonArrayConstructor(const JsonArrayConstructor *a, - const JsonArrayConstructor *b) -{ - COMPARE_NODE_FIELD(exprs); - COMPARE_NODE_FIELD(output); - COMPARE_SCALAR_FIELD(absent_on_null); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonArrayAgg(const JsonArrayAgg *a, const JsonArrayAgg *b) -{ - COMPARE_NODE_FIELD(constructor); - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(absent_on_null); - - return true; -} - -static bool -_equalJsonArrayQueryConstructor(const JsonArrayQueryConstructor *a, - const JsonArrayQueryConstructor *b) -{ - COMPARE_NODE_FIELD(query); - COMPARE_NODE_FIELD(output); - COMPARE_NODE_FIELD(format); - COMPARE_SCALAR_FIELD(absent_on_null); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonFuncExpr(const JsonFuncExpr *a, const JsonFuncExpr *b) -{ - COMPARE_SCALAR_FIELD(op); - COMPARE_NODE_FIELD(common); - COMPARE_NODE_FIELD(output); - COMPARE_NODE_FIELD(on_empty); - COMPARE_NODE_FIELD(on_error); - COMPARE_SCALAR_FIELD(wrapper); - COMPARE_SCALAR_FIELD(omit_quotes); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonCommon(const JsonCommon *a, const JsonCommon *b) -{ - COMPARE_NODE_FIELD(expr); - COMPARE_NODE_FIELD(pathspec); - COMPARE_STRING_FIELD(pathname); - COMPARE_NODE_FIELD(passing); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalJsonArgument(const JsonArgument *a, const JsonArgument *b) -{ - COMPARE_NODE_FIELD(val); - COMPARE_STRING_FIELD(name); - - return true; -} - -static bool -_equalJsonIsPredicate(const JsonIsPredicate *a, - const JsonIsPredicate *b) -{ - COMPARE_NODE_FIELD(expr); - COMPARE_NODE_FIELD(format); - COMPARE_SCALAR_FIELD(item_type); - COMPARE_SCALAR_FIELD(unique_keys); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -/* - * _equalJsonBehavior - */ -static bool -_equalJsonBehavior(const JsonBehavior *a, const JsonBehavior *b) -{ - COMPARE_SCALAR_FIELD(btype); - COMPARE_NODE_FIELD(default_expr); - - return true; -} - -/* - * _equalJsonExpr - */ -static bool -_equalJsonExpr(const JsonExpr *a, const JsonExpr *b) -{ - COMPARE_SCALAR_FIELD(op); - COMPARE_NODE_FIELD(formatted_expr); - COMPARE_NODE_FIELD(result_coercion); - COMPARE_NODE_FIELD(format); - COMPARE_NODE_FIELD(path_spec); - COMPARE_NODE_FIELD(passing_names); - COMPARE_NODE_FIELD(passing_values); - COMPARE_NODE_FIELD(returning); - COMPARE_NODE_FIELD(on_empty); - COMPARE_NODE_FIELD(on_error); - COMPARE_NODE_FIELD(coercions); - COMPARE_SCALAR_FIELD(wrapper); - COMPARE_SCALAR_FIELD(omit_quotes); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -/* - * _equalJsonCoercion - */ -static bool -_equalJsonCoercion(const JsonCoercion *a, const JsonCoercion *b) -{ - COMPARE_NODE_FIELD(expr); - COMPARE_SCALAR_FIELD(via_populate); - COMPARE_SCALAR_FIELD(via_io); - COMPARE_SCALAR_FIELD(collation); - - return true; -} - -/* - * _equalJsonItemCoercions - */ -static bool -_equalJsonItemCoercions(const JsonItemCoercions *a, const JsonItemCoercions *b) -{ - COMPARE_NODE_FIELD(null); - COMPARE_NODE_FIELD(string); - COMPARE_NODE_FIELD(numeric); - COMPARE_NODE_FIELD(boolean); - COMPARE_NODE_FIELD(date); - COMPARE_NODE_FIELD(time); - COMPARE_NODE_FIELD(timetz); - COMPARE_NODE_FIELD(timestamp); - COMPARE_NODE_FIELD(timestamptz); - COMPARE_NODE_FIELD(composite); - - return true; -} - -/* - * Stuff from pathnodes.h - */ - -static bool -_equalPathKey(const PathKey *a, const PathKey *b) -{ - /* We assume pointer equality is sufficient to compare the eclasses */ - COMPARE_SCALAR_FIELD(pk_eclass); - COMPARE_SCALAR_FIELD(pk_opfamily); - COMPARE_SCALAR_FIELD(pk_strategy); - COMPARE_SCALAR_FIELD(pk_nulls_first); - - return true; -} - -static bool -_equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b) -{ - COMPARE_NODE_FIELD(clause); - COMPARE_SCALAR_FIELD(is_pushed_down); - COMPARE_SCALAR_FIELD(outerjoin_delayed); - COMPARE_SCALAR_FIELD(security_level); - COMPARE_BITMAPSET_FIELD(required_relids); - COMPARE_BITMAPSET_FIELD(outer_relids); - COMPARE_BITMAPSET_FIELD(nullable_relids); - - /* - * We ignore all the remaining fields, since they may not be set yet, and - * should be derivable from the clause anyway. - */ - - return true; -} - -static bool -_equalPlaceHolderVar(const PlaceHolderVar *a, const PlaceHolderVar *b) -{ - /* - * We intentionally do not compare phexpr. Two PlaceHolderVars with the - * same ID and levelsup should be considered equal even if the contained - * expressions have managed to mutate to different states. This will - * happen during final plan construction when there are nested PHVs, since - * the inner PHV will get replaced by a Param in some copies of the outer - * PHV. Another way in which it can happen is that initplan sublinks - * could get replaced by differently-numbered Params when sublink folding - * is done. (The end result of such a situation would be some - * unreferenced initplans, which is annoying but not really a problem.) On - * the same reasoning, there is no need to examine phrels. - * - * COMPARE_NODE_FIELD(phexpr); - * - * COMPARE_BITMAPSET_FIELD(phrels); - */ - COMPARE_SCALAR_FIELD(phid); - COMPARE_SCALAR_FIELD(phlevelsup); - - return true; -} - -static bool -_equalSpecialJoinInfo(const SpecialJoinInfo *a, const SpecialJoinInfo *b) -{ - COMPARE_BITMAPSET_FIELD(min_lefthand); - COMPARE_BITMAPSET_FIELD(min_righthand); - COMPARE_BITMAPSET_FIELD(syn_lefthand); - COMPARE_BITMAPSET_FIELD(syn_righthand); - COMPARE_SCALAR_FIELD(jointype); - COMPARE_SCALAR_FIELD(lhs_strict); - COMPARE_SCALAR_FIELD(delay_upper_joins); - COMPARE_SCALAR_FIELD(semi_can_btree); - COMPARE_SCALAR_FIELD(semi_can_hash); - COMPARE_NODE_FIELD(semi_operators); - COMPARE_NODE_FIELD(semi_rhs_exprs); - - return true; -} - -static bool -_equalAppendRelInfo(const AppendRelInfo *a, const AppendRelInfo *b) -{ - COMPARE_SCALAR_FIELD(parent_relid); - COMPARE_SCALAR_FIELD(child_relid); - COMPARE_SCALAR_FIELD(parent_reltype); - COMPARE_SCALAR_FIELD(child_reltype); - COMPARE_NODE_FIELD(translated_vars); - COMPARE_SCALAR_FIELD(num_child_cols); - COMPARE_POINTER_FIELD(parent_colnos, a->num_child_cols * sizeof(AttrNumber)); - COMPARE_SCALAR_FIELD(parent_reloid); - - return true; -} - -static bool -_equalPlaceHolderInfo(const PlaceHolderInfo *a, const PlaceHolderInfo *b) -{ - COMPARE_SCALAR_FIELD(phid); - COMPARE_NODE_FIELD(ph_var); /* should be redundant */ - COMPARE_BITMAPSET_FIELD(ph_eval_at); - COMPARE_BITMAPSET_FIELD(ph_lateral); - COMPARE_BITMAPSET_FIELD(ph_needed); - COMPARE_SCALAR_FIELD(ph_width); - - return true; -} -#endif /* OBSOLETE */ - -/* - * Stuff from extensible.h - */ static bool _equalExtensibleNode(const ExtensibleNode *a, const ExtensibleNode *b) { @@ -1326,1499 +130,6 @@ _equalExtensibleNode(const ExtensibleNode *a, const ExtensibleNode *b) return true; } -#ifdef OBSOLETE -/* - * Stuff from parsenodes.h - */ - -static bool -_equalQuery(const Query *a, const Query *b) -{ - COMPARE_SCALAR_FIELD(commandType); - COMPARE_SCALAR_FIELD(querySource); - /* we intentionally ignore queryId, since it might not be set */ - COMPARE_SCALAR_FIELD(canSetTag); - COMPARE_NODE_FIELD(utilityStmt); - COMPARE_SCALAR_FIELD(resultRelation); - COMPARE_SCALAR_FIELD(hasAggs); - COMPARE_SCALAR_FIELD(hasWindowFuncs); - COMPARE_SCALAR_FIELD(hasTargetSRFs); - COMPARE_SCALAR_FIELD(hasSubLinks); - COMPARE_SCALAR_FIELD(hasDistinctOn); - COMPARE_SCALAR_FIELD(hasRecursive); - COMPARE_SCALAR_FIELD(hasModifyingCTE); - COMPARE_SCALAR_FIELD(hasForUpdate); - COMPARE_SCALAR_FIELD(hasRowSecurity); - COMPARE_SCALAR_FIELD(isReturn); - COMPARE_NODE_FIELD(cteList); - COMPARE_NODE_FIELD(rtable); - COMPARE_NODE_FIELD(jointree); - COMPARE_NODE_FIELD(targetList); - COMPARE_SCALAR_FIELD(override); - COMPARE_NODE_FIELD(onConflict); - COMPARE_NODE_FIELD(returningList); - COMPARE_NODE_FIELD(groupClause); - COMPARE_SCALAR_FIELD(groupDistinct); - COMPARE_NODE_FIELD(groupingSets); - COMPARE_NODE_FIELD(havingQual); - COMPARE_NODE_FIELD(windowClause); - COMPARE_NODE_FIELD(distinctClause); - COMPARE_NODE_FIELD(sortClause); - COMPARE_NODE_FIELD(limitOffset); - COMPARE_NODE_FIELD(limitCount); - COMPARE_SCALAR_FIELD(limitOption); - COMPARE_NODE_FIELD(rowMarks); - COMPARE_NODE_FIELD(setOperations); - COMPARE_NODE_FIELD(constraintDeps); - COMPARE_NODE_FIELD(withCheckOptions); - COMPARE_NODE_FIELD(mergeActionList); - COMPARE_SCALAR_FIELD(mergeUseOuterJoin); - COMPARE_LOCATION_FIELD(stmt_location); - COMPARE_SCALAR_FIELD(stmt_len); - - return true; -} - -static bool -_equalRawStmt(const RawStmt *a, const RawStmt *b) -{ - COMPARE_NODE_FIELD(stmt); - COMPARE_LOCATION_FIELD(stmt_location); - COMPARE_SCALAR_FIELD(stmt_len); - - return true; -} - -static bool -_equalInsertStmt(const InsertStmt *a, const InsertStmt *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(cols); - COMPARE_NODE_FIELD(selectStmt); - COMPARE_NODE_FIELD(onConflictClause); - COMPARE_NODE_FIELD(returningList); - COMPARE_NODE_FIELD(withClause); - COMPARE_SCALAR_FIELD(override); - - return true; -} - -static bool -_equalDeleteStmt(const DeleteStmt *a, const DeleteStmt *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(usingClause); - COMPARE_NODE_FIELD(whereClause); - COMPARE_NODE_FIELD(returningList); - COMPARE_NODE_FIELD(withClause); - - return true; -} - -static bool -_equalUpdateStmt(const UpdateStmt *a, const UpdateStmt *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(targetList); - COMPARE_NODE_FIELD(whereClause); - COMPARE_NODE_FIELD(fromClause); - COMPARE_NODE_FIELD(returningList); - COMPARE_NODE_FIELD(withClause); - - return true; -} - -static bool -_equalMergeStmt(const MergeStmt *a, const MergeStmt *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(sourceRelation); - COMPARE_NODE_FIELD(joinCondition); - COMPARE_NODE_FIELD(mergeWhenClauses); - COMPARE_NODE_FIELD(withClause); - - return true; -} - -static bool -_equalSelectStmt(const SelectStmt *a, const SelectStmt *b) -{ - COMPARE_NODE_FIELD(distinctClause); - COMPARE_NODE_FIELD(intoClause); - COMPARE_NODE_FIELD(targetList); - COMPARE_NODE_FIELD(fromClause); - COMPARE_NODE_FIELD(whereClause); - COMPARE_NODE_FIELD(groupClause); - COMPARE_SCALAR_FIELD(groupDistinct); - COMPARE_NODE_FIELD(havingClause); - COMPARE_NODE_FIELD(windowClause); - COMPARE_NODE_FIELD(valuesLists); - COMPARE_NODE_FIELD(sortClause); - COMPARE_NODE_FIELD(limitOffset); - COMPARE_NODE_FIELD(limitCount); - COMPARE_SCALAR_FIELD(limitOption); - COMPARE_NODE_FIELD(lockingClause); - COMPARE_NODE_FIELD(withClause); - COMPARE_SCALAR_FIELD(op); - COMPARE_SCALAR_FIELD(all); - COMPARE_NODE_FIELD(larg); - COMPARE_NODE_FIELD(rarg); - - return true; -} - -static bool -_equalSetOperationStmt(const SetOperationStmt *a, const SetOperationStmt *b) -{ - COMPARE_SCALAR_FIELD(op); - COMPARE_SCALAR_FIELD(all); - COMPARE_NODE_FIELD(larg); - COMPARE_NODE_FIELD(rarg); - COMPARE_NODE_FIELD(colTypes); - COMPARE_NODE_FIELD(colTypmods); - COMPARE_NODE_FIELD(colCollations); - COMPARE_NODE_FIELD(groupClauses); - - return true; -} - -static bool -_equalReturnStmt(const ReturnStmt *a, const ReturnStmt *b) -{ - COMPARE_NODE_FIELD(returnval); - - return true; -} - -static bool -_equalPLAssignStmt(const PLAssignStmt *a, const PLAssignStmt *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(indirection); - COMPARE_SCALAR_FIELD(nnames); - COMPARE_NODE_FIELD(val); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(cmds); - COMPARE_SCALAR_FIELD(objtype); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b) -{ - COMPARE_SCALAR_FIELD(subtype); - COMPARE_STRING_FIELD(name); - COMPARE_SCALAR_FIELD(num); - COMPARE_NODE_FIELD(newowner); - COMPARE_NODE_FIELD(def); - COMPARE_SCALAR_FIELD(behavior); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalAlterCollationStmt(const AlterCollationStmt *a, const AlterCollationStmt *b) -{ - COMPARE_NODE_FIELD(collname); - - return true; -} - -static bool -_equalAlterDomainStmt(const AlterDomainStmt *a, const AlterDomainStmt *b) -{ - COMPARE_SCALAR_FIELD(subtype); - COMPARE_NODE_FIELD(typeName); - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(def); - COMPARE_SCALAR_FIELD(behavior); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalGrantStmt(const GrantStmt *a, const GrantStmt *b) -{ - COMPARE_SCALAR_FIELD(is_grant); - COMPARE_SCALAR_FIELD(targtype); - COMPARE_SCALAR_FIELD(objtype); - COMPARE_NODE_FIELD(objects); - COMPARE_NODE_FIELD(privileges); - COMPARE_NODE_FIELD(grantees); - COMPARE_SCALAR_FIELD(grant_option); - COMPARE_NODE_FIELD(grantor); - COMPARE_SCALAR_FIELD(behavior); - - return true; -} - -static bool -_equalObjectWithArgs(const ObjectWithArgs *a, const ObjectWithArgs *b) -{ - COMPARE_NODE_FIELD(objname); - COMPARE_NODE_FIELD(objargs); - COMPARE_NODE_FIELD(objfuncargs); - COMPARE_SCALAR_FIELD(args_unspecified); - - return true; -} - -static bool -_equalAccessPriv(const AccessPriv *a, const AccessPriv *b) -{ - COMPARE_STRING_FIELD(priv_name); - COMPARE_NODE_FIELD(cols); - - return true; -} - -static bool -_equalGrantRoleStmt(const GrantRoleStmt *a, const GrantRoleStmt *b) -{ - COMPARE_NODE_FIELD(granted_roles); - COMPARE_NODE_FIELD(grantee_roles); - COMPARE_SCALAR_FIELD(is_grant); - COMPARE_SCALAR_FIELD(admin_opt); - COMPARE_NODE_FIELD(grantor); - COMPARE_SCALAR_FIELD(behavior); - - return true; -} - -static bool -_equalAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *a, const AlterDefaultPrivilegesStmt *b) -{ - COMPARE_NODE_FIELD(options); - COMPARE_NODE_FIELD(action); - - return true; -} - -static bool -_equalDeclareCursorStmt(const DeclareCursorStmt *a, const DeclareCursorStmt *b) -{ - COMPARE_STRING_FIELD(portalname); - COMPARE_SCALAR_FIELD(options); - COMPARE_NODE_FIELD(query); - - return true; -} - -static bool -_equalClosePortalStmt(const ClosePortalStmt *a, const ClosePortalStmt *b) -{ - COMPARE_STRING_FIELD(portalname); - - return true; -} - -static bool -_equalCallStmt(const CallStmt *a, const CallStmt *b) -{ - COMPARE_NODE_FIELD(funccall); - COMPARE_NODE_FIELD(funcexpr); - COMPARE_NODE_FIELD(outargs); - - return true; -} - -static bool -_equalClusterStmt(const ClusterStmt *a, const ClusterStmt *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_STRING_FIELD(indexname); - COMPARE_NODE_FIELD(params); - - return true; -} - -static bool -_equalCopyStmt(const CopyStmt *a, const CopyStmt *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(query); - COMPARE_NODE_FIELD(attlist); - COMPARE_SCALAR_FIELD(is_from); - COMPARE_SCALAR_FIELD(is_program); - COMPARE_STRING_FIELD(filename); - COMPARE_NODE_FIELD(options); - COMPARE_NODE_FIELD(whereClause); - - return true; -} - -static bool -_equalCreateStmt(const CreateStmt *a, const CreateStmt *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(tableElts); - COMPARE_NODE_FIELD(inhRelations); - COMPARE_NODE_FIELD(partbound); - COMPARE_NODE_FIELD(partspec); - COMPARE_NODE_FIELD(ofTypename); - COMPARE_NODE_FIELD(constraints); - COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(oncommit); - COMPARE_STRING_FIELD(tablespacename); - COMPARE_STRING_FIELD(accessMethod); - COMPARE_SCALAR_FIELD(if_not_exists); - - return true; -} - -static bool -_equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_SCALAR_FIELD(options); - COMPARE_SCALAR_FIELD(relationOid); - - return true; -} - -static bool -_equalDefineStmt(const DefineStmt *a, const DefineStmt *b) -{ - COMPARE_SCALAR_FIELD(kind); - COMPARE_SCALAR_FIELD(oldstyle); - COMPARE_NODE_FIELD(defnames); - COMPARE_NODE_FIELD(args); - COMPARE_NODE_FIELD(definition); - COMPARE_SCALAR_FIELD(if_not_exists); - COMPARE_SCALAR_FIELD(replace); - - return true; -} - -static bool -_equalDropStmt(const DropStmt *a, const DropStmt *b) -{ - COMPARE_NODE_FIELD(objects); - COMPARE_SCALAR_FIELD(removeType); - COMPARE_SCALAR_FIELD(behavior); - COMPARE_SCALAR_FIELD(missing_ok); - COMPARE_SCALAR_FIELD(concurrent); - - return true; -} - -static bool -_equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b) -{ - COMPARE_NODE_FIELD(relations); - COMPARE_SCALAR_FIELD(restart_seqs); - COMPARE_SCALAR_FIELD(behavior); - - return true; -} - -static bool -_equalCommentStmt(const CommentStmt *a, const CommentStmt *b) -{ - COMPARE_SCALAR_FIELD(objtype); - COMPARE_NODE_FIELD(object); - COMPARE_STRING_FIELD(comment); - - return true; -} - -static bool -_equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b) -{ - COMPARE_SCALAR_FIELD(objtype); - COMPARE_NODE_FIELD(object); - COMPARE_STRING_FIELD(provider); - COMPARE_STRING_FIELD(label); - - return true; -} - -static bool -_equalFetchStmt(const FetchStmt *a, const FetchStmt *b) -{ - COMPARE_SCALAR_FIELD(direction); - COMPARE_SCALAR_FIELD(howMany); - COMPARE_STRING_FIELD(portalname); - COMPARE_SCALAR_FIELD(ismove); - - return true; -} - -static bool -_equalIndexStmt(const IndexStmt *a, const IndexStmt *b) -{ - COMPARE_STRING_FIELD(idxname); - COMPARE_NODE_FIELD(relation); - COMPARE_STRING_FIELD(accessMethod); - COMPARE_STRING_FIELD(tableSpace); - COMPARE_NODE_FIELD(indexParams); - COMPARE_NODE_FIELD(indexIncludingParams); - COMPARE_NODE_FIELD(options); - COMPARE_NODE_FIELD(whereClause); - COMPARE_NODE_FIELD(excludeOpNames); - COMPARE_STRING_FIELD(idxcomment); - COMPARE_SCALAR_FIELD(indexOid); - COMPARE_SCALAR_FIELD(oldNumber); - COMPARE_SCALAR_FIELD(oldCreateSubid); - COMPARE_SCALAR_FIELD(oldFirstRelfilelocatorSubid); - COMPARE_SCALAR_FIELD(unique); - COMPARE_SCALAR_FIELD(nulls_not_distinct); - COMPARE_SCALAR_FIELD(primary); - COMPARE_SCALAR_FIELD(isconstraint); - COMPARE_SCALAR_FIELD(deferrable); - COMPARE_SCALAR_FIELD(initdeferred); - COMPARE_SCALAR_FIELD(transformed); - COMPARE_SCALAR_FIELD(concurrent); - COMPARE_SCALAR_FIELD(if_not_exists); - COMPARE_SCALAR_FIELD(reset_default_tblspc); - - return true; -} - -static bool -_equalCreateStatsStmt(const CreateStatsStmt *a, const CreateStatsStmt *b) -{ - COMPARE_NODE_FIELD(defnames); - COMPARE_NODE_FIELD(stat_types); - COMPARE_NODE_FIELD(exprs); - COMPARE_NODE_FIELD(relations); - COMPARE_STRING_FIELD(stxcomment); - COMPARE_SCALAR_FIELD(transformed); - COMPARE_SCALAR_FIELD(if_not_exists); - - return true; -} - -static bool -_equalAlterStatsStmt(const AlterStatsStmt *a, const AlterStatsStmt *b) -{ - COMPARE_NODE_FIELD(defnames); - COMPARE_SCALAR_FIELD(stxstattarget); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalCreateFunctionStmt(const CreateFunctionStmt *a, const CreateFunctionStmt *b) -{ - COMPARE_SCALAR_FIELD(is_procedure); - COMPARE_SCALAR_FIELD(replace); - COMPARE_NODE_FIELD(funcname); - COMPARE_NODE_FIELD(parameters); - COMPARE_NODE_FIELD(returnType); - COMPARE_NODE_FIELD(options); - COMPARE_NODE_FIELD(sql_body); - - return true; -} - -static bool -_equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(argType); - COMPARE_SCALAR_FIELD(mode); - COMPARE_NODE_FIELD(defexpr); - - return true; -} - -static bool -_equalAlterFunctionStmt(const AlterFunctionStmt *a, const AlterFunctionStmt *b) -{ - COMPARE_SCALAR_FIELD(objtype); - COMPARE_NODE_FIELD(func); - COMPARE_NODE_FIELD(actions); - - return true; -} - -static bool -_equalDoStmt(const DoStmt *a, const DoStmt *b) -{ - COMPARE_NODE_FIELD(args); - - return true; -} - -static bool -_equalRenameStmt(const RenameStmt *a, const RenameStmt *b) -{ - COMPARE_SCALAR_FIELD(renameType); - COMPARE_SCALAR_FIELD(relationType); - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(object); - COMPARE_STRING_FIELD(subname); - COMPARE_STRING_FIELD(newname); - COMPARE_SCALAR_FIELD(behavior); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalAlterObjectDependsStmt(const AlterObjectDependsStmt *a, const AlterObjectDependsStmt *b) -{ - COMPARE_SCALAR_FIELD(objectType); - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(object); - COMPARE_NODE_FIELD(extname); - COMPARE_SCALAR_FIELD(remove); - - return true; -} - -static bool -_equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b) -{ - COMPARE_SCALAR_FIELD(objectType); - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(object); - COMPARE_STRING_FIELD(newschema); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalAlterOwnerStmt(const AlterOwnerStmt *a, const AlterOwnerStmt *b) -{ - COMPARE_SCALAR_FIELD(objectType); - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(object); - COMPARE_NODE_FIELD(newowner); - - return true; -} - -static bool -_equalAlterOperatorStmt(const AlterOperatorStmt *a, const AlterOperatorStmt *b) -{ - COMPARE_NODE_FIELD(opername); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterTypeStmt(const AlterTypeStmt *a, const AlterTypeStmt *b) -{ - COMPARE_NODE_FIELD(typeName); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalRuleStmt(const RuleStmt *a, const RuleStmt *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_STRING_FIELD(rulename); - COMPARE_NODE_FIELD(whereClause); - COMPARE_SCALAR_FIELD(event); - COMPARE_SCALAR_FIELD(instead); - COMPARE_NODE_FIELD(actions); - COMPARE_SCALAR_FIELD(replace); - - return true; -} - -static bool -_equalNotifyStmt(const NotifyStmt *a, const NotifyStmt *b) -{ - COMPARE_STRING_FIELD(conditionname); - COMPARE_STRING_FIELD(payload); - - return true; -} - -static bool -_equalListenStmt(const ListenStmt *a, const ListenStmt *b) -{ - COMPARE_STRING_FIELD(conditionname); - - return true; -} - -static bool -_equalUnlistenStmt(const UnlistenStmt *a, const UnlistenStmt *b) -{ - COMPARE_STRING_FIELD(conditionname); - - return true; -} - -static bool -_equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b) -{ - COMPARE_SCALAR_FIELD(kind); - COMPARE_NODE_FIELD(options); - COMPARE_STRING_FIELD(savepoint_name); - COMPARE_STRING_FIELD(gid); - COMPARE_SCALAR_FIELD(chain); - - return true; -} - -static bool -_equalCompositeTypeStmt(const CompositeTypeStmt *a, const CompositeTypeStmt *b) -{ - COMPARE_NODE_FIELD(typevar); - COMPARE_NODE_FIELD(coldeflist); - - return true; -} - -static bool -_equalCreateEnumStmt(const CreateEnumStmt *a, const CreateEnumStmt *b) -{ - COMPARE_NODE_FIELD(typeName); - COMPARE_NODE_FIELD(vals); - - return true; -} - -static bool -_equalCreateRangeStmt(const CreateRangeStmt *a, const CreateRangeStmt *b) -{ - COMPARE_NODE_FIELD(typeName); - COMPARE_NODE_FIELD(params); - - return true; -} - -static bool -_equalAlterEnumStmt(const AlterEnumStmt *a, const AlterEnumStmt *b) -{ - COMPARE_NODE_FIELD(typeName); - COMPARE_STRING_FIELD(oldVal); - COMPARE_STRING_FIELD(newVal); - COMPARE_STRING_FIELD(newValNeighbor); - COMPARE_SCALAR_FIELD(newValIsAfter); - COMPARE_SCALAR_FIELD(skipIfNewValExists); - - return true; -} - -static bool -_equalViewStmt(const ViewStmt *a, const ViewStmt *b) -{ - COMPARE_NODE_FIELD(view); - COMPARE_NODE_FIELD(aliases); - COMPARE_NODE_FIELD(query); - COMPARE_SCALAR_FIELD(replace); - COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(withCheckOption); - - return true; -} - -static bool -_equalLoadStmt(const LoadStmt *a, const LoadStmt *b) -{ - COMPARE_STRING_FIELD(filename); - - return true; -} - -static bool -_equalCreateDomainStmt(const CreateDomainStmt *a, const CreateDomainStmt *b) -{ - COMPARE_NODE_FIELD(domainname); - COMPARE_NODE_FIELD(typeName); - COMPARE_NODE_FIELD(collClause); - COMPARE_NODE_FIELD(constraints); - - return true; -} - -static bool -_equalCreateOpClassStmt(const CreateOpClassStmt *a, const CreateOpClassStmt *b) -{ - COMPARE_NODE_FIELD(opclassname); - COMPARE_NODE_FIELD(opfamilyname); - COMPARE_STRING_FIELD(amname); - COMPARE_NODE_FIELD(datatype); - COMPARE_NODE_FIELD(items); - COMPARE_SCALAR_FIELD(isDefault); - - return true; -} - -static bool -_equalCreateOpClassItem(const CreateOpClassItem *a, const CreateOpClassItem *b) -{ - COMPARE_SCALAR_FIELD(itemtype); - COMPARE_NODE_FIELD(name); - COMPARE_SCALAR_FIELD(number); - COMPARE_NODE_FIELD(order_family); - COMPARE_NODE_FIELD(class_args); - COMPARE_NODE_FIELD(storedtype); - - return true; -} - -static bool -_equalCreateOpFamilyStmt(const CreateOpFamilyStmt *a, const CreateOpFamilyStmt *b) -{ - COMPARE_NODE_FIELD(opfamilyname); - COMPARE_STRING_FIELD(amname); - - return true; -} - -static bool -_equalAlterOpFamilyStmt(const AlterOpFamilyStmt *a, const AlterOpFamilyStmt *b) -{ - COMPARE_NODE_FIELD(opfamilyname); - COMPARE_STRING_FIELD(amname); - COMPARE_SCALAR_FIELD(isDrop); - COMPARE_NODE_FIELD(items); - - return true; -} - -static bool -_equalCreatedbStmt(const CreatedbStmt *a, const CreatedbStmt *b) -{ - COMPARE_STRING_FIELD(dbname); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterDatabaseStmt(const AlterDatabaseStmt *a, const AlterDatabaseStmt *b) -{ - COMPARE_STRING_FIELD(dbname); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt *a, const AlterDatabaseRefreshCollStmt *b) -{ - COMPARE_STRING_FIELD(dbname); - - return true; -} - -static bool -_equalAlterDatabaseSetStmt(const AlterDatabaseSetStmt *a, const AlterDatabaseSetStmt *b) -{ - COMPARE_STRING_FIELD(dbname); - COMPARE_NODE_FIELD(setstmt); - - return true; -} - -static bool -_equalDropdbStmt(const DropdbStmt *a, const DropdbStmt *b) -{ - COMPARE_STRING_FIELD(dbname); - COMPARE_SCALAR_FIELD(missing_ok); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b) -{ - COMPARE_NODE_FIELD(options); - COMPARE_NODE_FIELD(rels); - COMPARE_SCALAR_FIELD(is_vacuumcmd); - - return true; -} - -static bool -_equalVacuumRelation(const VacuumRelation *a, const VacuumRelation *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_SCALAR_FIELD(oid); - COMPARE_NODE_FIELD(va_cols); - - return true; -} - -static bool -_equalExplainStmt(const ExplainStmt *a, const ExplainStmt *b) -{ - COMPARE_NODE_FIELD(query); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalCreateTableAsStmt(const CreateTableAsStmt *a, const CreateTableAsStmt *b) -{ - COMPARE_NODE_FIELD(query); - COMPARE_NODE_FIELD(into); - COMPARE_SCALAR_FIELD(objtype); - COMPARE_SCALAR_FIELD(is_select_into); - COMPARE_SCALAR_FIELD(if_not_exists); - - return true; -} - -static bool -_equalRefreshMatViewStmt(const RefreshMatViewStmt *a, const RefreshMatViewStmt *b) -{ - COMPARE_SCALAR_FIELD(concurrent); - COMPARE_SCALAR_FIELD(skipData); - COMPARE_NODE_FIELD(relation); - - return true; -} - -static bool -_equalReplicaIdentityStmt(const ReplicaIdentityStmt *a, const ReplicaIdentityStmt *b) -{ - COMPARE_SCALAR_FIELD(identity_type); - COMPARE_STRING_FIELD(name); - - return true; -} - -static bool -_equalAlterSystemStmt(const AlterSystemStmt *a, const AlterSystemStmt *b) -{ - COMPARE_NODE_FIELD(setstmt); - - return true; -} - - -static bool -_equalCreateSeqStmt(const CreateSeqStmt *a, const CreateSeqStmt *b) -{ - COMPARE_NODE_FIELD(sequence); - COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(ownerId); - COMPARE_SCALAR_FIELD(for_identity); - COMPARE_SCALAR_FIELD(if_not_exists); - - return true; -} - -static bool -_equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b) -{ - COMPARE_NODE_FIELD(sequence); - COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(for_identity); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalVariableSetStmt(const VariableSetStmt *a, const VariableSetStmt *b) -{ - COMPARE_SCALAR_FIELD(kind); - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(args); - COMPARE_SCALAR_FIELD(is_local); - - return true; -} - -static bool -_equalVariableShowStmt(const VariableShowStmt *a, const VariableShowStmt *b) -{ - COMPARE_STRING_FIELD(name); - - return true; -} - -static bool -_equalDiscardStmt(const DiscardStmt *a, const DiscardStmt *b) -{ - COMPARE_SCALAR_FIELD(target); - - return true; -} - -static bool -_equalCreateTableSpaceStmt(const CreateTableSpaceStmt *a, const CreateTableSpaceStmt *b) -{ - COMPARE_STRING_FIELD(tablespacename); - COMPARE_NODE_FIELD(owner); - COMPARE_STRING_FIELD(location); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalDropTableSpaceStmt(const DropTableSpaceStmt *a, const DropTableSpaceStmt *b) -{ - COMPARE_STRING_FIELD(tablespacename); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *a, - const AlterTableSpaceOptionsStmt *b) -{ - COMPARE_STRING_FIELD(tablespacename); - COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(isReset); - - return true; -} - -static bool -_equalAlterTableMoveAllStmt(const AlterTableMoveAllStmt *a, - const AlterTableMoveAllStmt *b) -{ - COMPARE_STRING_FIELD(orig_tablespacename); - COMPARE_SCALAR_FIELD(objtype); - COMPARE_NODE_FIELD(roles); - COMPARE_STRING_FIELD(new_tablespacename); - COMPARE_SCALAR_FIELD(nowait); - - return true; -} - -static bool -_equalCreateExtensionStmt(const CreateExtensionStmt *a, const CreateExtensionStmt *b) -{ - COMPARE_STRING_FIELD(extname); - COMPARE_SCALAR_FIELD(if_not_exists); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterExtensionStmt(const AlterExtensionStmt *a, const AlterExtensionStmt *b) -{ - COMPARE_STRING_FIELD(extname); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterExtensionContentsStmt(const AlterExtensionContentsStmt *a, const AlterExtensionContentsStmt *b) -{ - COMPARE_STRING_FIELD(extname); - COMPARE_SCALAR_FIELD(action); - COMPARE_SCALAR_FIELD(objtype); - COMPARE_NODE_FIELD(object); - - return true; -} - -static bool -_equalCreateFdwStmt(const CreateFdwStmt *a, const CreateFdwStmt *b) -{ - COMPARE_STRING_FIELD(fdwname); - COMPARE_NODE_FIELD(func_options); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterFdwStmt(const AlterFdwStmt *a, const AlterFdwStmt *b) -{ - COMPARE_STRING_FIELD(fdwname); - COMPARE_NODE_FIELD(func_options); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalCreateForeignServerStmt(const CreateForeignServerStmt *a, const CreateForeignServerStmt *b) -{ - COMPARE_STRING_FIELD(servername); - COMPARE_STRING_FIELD(servertype); - COMPARE_STRING_FIELD(version); - COMPARE_STRING_FIELD(fdwname); - COMPARE_SCALAR_FIELD(if_not_exists); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterForeignServerStmt(const AlterForeignServerStmt *a, const AlterForeignServerStmt *b) -{ - COMPARE_STRING_FIELD(servername); - COMPARE_STRING_FIELD(version); - COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(has_version); - - return true; -} - -static bool -_equalCreateUserMappingStmt(const CreateUserMappingStmt *a, const CreateUserMappingStmt *b) -{ - COMPARE_NODE_FIELD(user); - COMPARE_STRING_FIELD(servername); - COMPARE_SCALAR_FIELD(if_not_exists); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterUserMappingStmt(const AlterUserMappingStmt *a, const AlterUserMappingStmt *b) -{ - COMPARE_NODE_FIELD(user); - COMPARE_STRING_FIELD(servername); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStmt *b) -{ - COMPARE_NODE_FIELD(user); - COMPARE_STRING_FIELD(servername); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalCreateForeignTableStmt(const CreateForeignTableStmt *a, const CreateForeignTableStmt *b) -{ - if (!_equalCreateStmt(&a->base, &b->base)) - return false; - - COMPARE_STRING_FIELD(servername); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalImportForeignSchemaStmt(const ImportForeignSchemaStmt *a, const ImportForeignSchemaStmt *b) -{ - COMPARE_STRING_FIELD(server_name); - COMPARE_STRING_FIELD(remote_schema); - COMPARE_STRING_FIELD(local_schema); - COMPARE_SCALAR_FIELD(list_type); - COMPARE_NODE_FIELD(table_list); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalCreateTransformStmt(const CreateTransformStmt *a, const CreateTransformStmt *b) -{ - COMPARE_SCALAR_FIELD(replace); - COMPARE_NODE_FIELD(type_name); - COMPARE_STRING_FIELD(lang); - COMPARE_NODE_FIELD(fromsql); - COMPARE_NODE_FIELD(tosql); - - return true; -} - -static bool -_equalCreateAmStmt(const CreateAmStmt *a, const CreateAmStmt *b) -{ - COMPARE_STRING_FIELD(amname); - COMPARE_NODE_FIELD(handler_name); - COMPARE_SCALAR_FIELD(amtype); - - return true; -} - -static bool -_equalCreateTrigStmt(const CreateTrigStmt *a, const CreateTrigStmt *b) -{ - COMPARE_SCALAR_FIELD(replace); - COMPARE_SCALAR_FIELD(isconstraint); - COMPARE_STRING_FIELD(trigname); - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(funcname); - COMPARE_NODE_FIELD(args); - COMPARE_SCALAR_FIELD(row); - COMPARE_SCALAR_FIELD(timing); - COMPARE_SCALAR_FIELD(events); - COMPARE_NODE_FIELD(columns); - COMPARE_NODE_FIELD(whenClause); - COMPARE_NODE_FIELD(transitionRels); - COMPARE_SCALAR_FIELD(deferrable); - COMPARE_SCALAR_FIELD(initdeferred); - COMPARE_NODE_FIELD(constrrel); - - return true; -} - -static bool -_equalCreateEventTrigStmt(const CreateEventTrigStmt *a, const CreateEventTrigStmt *b) -{ - COMPARE_STRING_FIELD(trigname); - COMPARE_STRING_FIELD(eventname); - COMPARE_NODE_FIELD(whenclause); - COMPARE_NODE_FIELD(funcname); - - return true; -} - -static bool -_equalAlterEventTrigStmt(const AlterEventTrigStmt *a, const AlterEventTrigStmt *b) -{ - COMPARE_STRING_FIELD(trigname); - COMPARE_SCALAR_FIELD(tgenabled); - - return true; -} - -static bool -_equalCreatePLangStmt(const CreatePLangStmt *a, const CreatePLangStmt *b) -{ - COMPARE_SCALAR_FIELD(replace); - COMPARE_STRING_FIELD(plname); - COMPARE_NODE_FIELD(plhandler); - COMPARE_NODE_FIELD(plinline); - COMPARE_NODE_FIELD(plvalidator); - COMPARE_SCALAR_FIELD(pltrusted); - - return true; -} - -static bool -_equalCreateRoleStmt(const CreateRoleStmt *a, const CreateRoleStmt *b) -{ - COMPARE_SCALAR_FIELD(stmt_type); - COMPARE_STRING_FIELD(role); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterRoleStmt(const AlterRoleStmt *a, const AlterRoleStmt *b) -{ - COMPARE_NODE_FIELD(role); - COMPARE_NODE_FIELD(options); - COMPARE_SCALAR_FIELD(action); - - return true; -} - -static bool -_equalAlterRoleSetStmt(const AlterRoleSetStmt *a, const AlterRoleSetStmt *b) -{ - COMPARE_NODE_FIELD(role); - COMPARE_STRING_FIELD(database); - COMPARE_NODE_FIELD(setstmt); - - return true; -} - -static bool -_equalDropRoleStmt(const DropRoleStmt *a, const DropRoleStmt *b) -{ - COMPARE_NODE_FIELD(roles); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalLockStmt(const LockStmt *a, const LockStmt *b) -{ - COMPARE_NODE_FIELD(relations); - COMPARE_SCALAR_FIELD(mode); - COMPARE_SCALAR_FIELD(nowait); - - return true; -} - -static bool -_equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt *b) -{ - COMPARE_NODE_FIELD(constraints); - COMPARE_SCALAR_FIELD(deferred); - - return true; -} - -static bool -_equalReindexStmt(const ReindexStmt *a, const ReindexStmt *b) -{ - COMPARE_SCALAR_FIELD(kind); - COMPARE_NODE_FIELD(relation); - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(params); - - return true; -} - -static bool -_equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b) -{ - COMPARE_STRING_FIELD(schemaname); - COMPARE_NODE_FIELD(authrole); - COMPARE_NODE_FIELD(schemaElts); - COMPARE_SCALAR_FIELD(if_not_exists); - - return true; -} - -static bool -_equalCreateConversionStmt(const CreateConversionStmt *a, const CreateConversionStmt *b) -{ - COMPARE_NODE_FIELD(conversion_name); - COMPARE_STRING_FIELD(for_encoding_name); - COMPARE_STRING_FIELD(to_encoding_name); - COMPARE_NODE_FIELD(func_name); - COMPARE_SCALAR_FIELD(def); - - return true; -} - -static bool -_equalCreateCastStmt(const CreateCastStmt *a, const CreateCastStmt *b) -{ - COMPARE_NODE_FIELD(sourcetype); - COMPARE_NODE_FIELD(targettype); - COMPARE_NODE_FIELD(func); - COMPARE_SCALAR_FIELD(context); - COMPARE_SCALAR_FIELD(inout); - - return true; -} - -static bool -_equalPrepareStmt(const PrepareStmt *a, const PrepareStmt *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(argtypes); - COMPARE_NODE_FIELD(query); - - return true; -} - -static bool -_equalExecuteStmt(const ExecuteStmt *a, const ExecuteStmt *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(params); - - return true; -} - -static bool -_equalDeallocateStmt(const DeallocateStmt *a, const DeallocateStmt *b) -{ - COMPARE_STRING_FIELD(name); - - return true; -} - -static bool -_equalDropOwnedStmt(const DropOwnedStmt *a, const DropOwnedStmt *b) -{ - COMPARE_NODE_FIELD(roles); - COMPARE_SCALAR_FIELD(behavior); - - return true; -} - -static bool -_equalReassignOwnedStmt(const ReassignOwnedStmt *a, const ReassignOwnedStmt *b) -{ - COMPARE_NODE_FIELD(roles); - COMPARE_NODE_FIELD(newrole); - - return true; -} - -static bool -_equalAlterTSDictionaryStmt(const AlterTSDictionaryStmt *a, const AlterTSDictionaryStmt *b) -{ - COMPARE_NODE_FIELD(dictname); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt *a, - const AlterTSConfigurationStmt *b) -{ - COMPARE_SCALAR_FIELD(kind); - COMPARE_NODE_FIELD(cfgname); - COMPARE_NODE_FIELD(tokentype); - COMPARE_NODE_FIELD(dicts); - COMPARE_SCALAR_FIELD(override); - COMPARE_SCALAR_FIELD(replace); - COMPARE_SCALAR_FIELD(missing_ok); - - return true; -} - -static bool -_equalPublicationObject(const PublicationObjSpec *a, - const PublicationObjSpec *b) -{ - COMPARE_SCALAR_FIELD(pubobjtype); - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(pubtable); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalPublicationTable(const PublicationTable *a, const PublicationTable *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(whereClause); - COMPARE_NODE_FIELD(columns); - - return true; -} - -static bool -_equalCreatePublicationStmt(const CreatePublicationStmt *a, - const CreatePublicationStmt *b) -{ - COMPARE_STRING_FIELD(pubname); - COMPARE_NODE_FIELD(options); - COMPARE_NODE_FIELD(pubobjects); - COMPARE_SCALAR_FIELD(for_all_tables); - - return true; -} - -static bool -_equalAlterPublicationStmt(const AlterPublicationStmt *a, - const AlterPublicationStmt *b) -{ - COMPARE_STRING_FIELD(pubname); - COMPARE_NODE_FIELD(options); - COMPARE_NODE_FIELD(pubobjects); - COMPARE_SCALAR_FIELD(for_all_tables); - COMPARE_SCALAR_FIELD(action); - - return true; -} - -static bool -_equalCreateSubscriptionStmt(const CreateSubscriptionStmt *a, - const CreateSubscriptionStmt *b) -{ - COMPARE_STRING_FIELD(subname); - COMPARE_STRING_FIELD(conninfo); - COMPARE_NODE_FIELD(publication); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalAlterSubscriptionStmt(const AlterSubscriptionStmt *a, - const AlterSubscriptionStmt *b) -{ - COMPARE_SCALAR_FIELD(kind); - COMPARE_STRING_FIELD(subname); - COMPARE_STRING_FIELD(conninfo); - COMPARE_NODE_FIELD(publication); - COMPARE_NODE_FIELD(options); - - return true; -} - -static bool -_equalDropSubscriptionStmt(const DropSubscriptionStmt *a, - const DropSubscriptionStmt *b) -{ - COMPARE_STRING_FIELD(subname); - COMPARE_SCALAR_FIELD(missing_ok); - COMPARE_SCALAR_FIELD(behavior); - - return true; -} - -static bool -_equalCreatePolicyStmt(const CreatePolicyStmt *a, const CreatePolicyStmt *b) -{ - COMPARE_STRING_FIELD(policy_name); - COMPARE_NODE_FIELD(table); - COMPARE_STRING_FIELD(cmd_name); - COMPARE_SCALAR_FIELD(permissive); - COMPARE_NODE_FIELD(roles); - COMPARE_NODE_FIELD(qual); - COMPARE_NODE_FIELD(with_check); - - return true; -} - -static bool -_equalAlterPolicyStmt(const AlterPolicyStmt *a, const AlterPolicyStmt *b) -{ - COMPARE_STRING_FIELD(policy_name); - COMPARE_NODE_FIELD(table); - COMPARE_NODE_FIELD(roles); - COMPARE_NODE_FIELD(qual); - COMPARE_NODE_FIELD(with_check); - - return true; -} - -static bool -_equalA_Expr(const A_Expr *a, const A_Expr *b) -{ - COMPARE_SCALAR_FIELD(kind); - COMPARE_NODE_FIELD(name); - COMPARE_NODE_FIELD(lexpr); - COMPARE_NODE_FIELD(rexpr); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalColumnRef(const ColumnRef *a, const ColumnRef *b) -{ - COMPARE_NODE_FIELD(fields); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalParamRef(const ParamRef *a, const ParamRef *b) -{ - COMPARE_SCALAR_FIELD(number); - COMPARE_LOCATION_FIELD(location); - - return true; -} -#endif /* OBSOLETE */ - static bool _equalA_Const(const A_Const *a, const A_Const *b) { @@ -2834,650 +145,9 @@ _equalA_Const(const A_Const *a, const A_Const *b) return true; } -#ifdef OBSOLETE -static bool -_equalFuncCall(const FuncCall *a, const FuncCall *b) -{ - COMPARE_NODE_FIELD(funcname); - COMPARE_NODE_FIELD(args); - COMPARE_NODE_FIELD(agg_order); - COMPARE_NODE_FIELD(agg_filter); - COMPARE_NODE_FIELD(over); - COMPARE_SCALAR_FIELD(agg_within_group); - COMPARE_SCALAR_FIELD(agg_star); - COMPARE_SCALAR_FIELD(agg_distinct); - COMPARE_SCALAR_FIELD(func_variadic); - COMPARE_COERCIONFORM_FIELD(funcformat); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalA_Star(const A_Star *a, const A_Star *b) -{ - return true; -} - -static bool -_equalA_Indices(const A_Indices *a, const A_Indices *b) -{ - COMPARE_SCALAR_FIELD(is_slice); - COMPARE_NODE_FIELD(lidx); - COMPARE_NODE_FIELD(uidx); - - return true; -} - -static bool -_equalA_Indirection(const A_Indirection *a, const A_Indirection *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_NODE_FIELD(indirection); - - return true; -} - -static bool -_equalA_ArrayExpr(const A_ArrayExpr *a, const A_ArrayExpr *b) -{ - COMPARE_NODE_FIELD(elements); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalResTarget(const ResTarget *a, const ResTarget *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(indirection); - COMPARE_NODE_FIELD(val); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalMultiAssignRef(const MultiAssignRef *a, const MultiAssignRef *b) -{ - COMPARE_NODE_FIELD(source); - COMPARE_SCALAR_FIELD(colno); - COMPARE_SCALAR_FIELD(ncolumns); - - return true; -} - -static bool -_equalTypeName(const TypeName *a, const TypeName *b) -{ - COMPARE_NODE_FIELD(names); - COMPARE_SCALAR_FIELD(typeOid); - COMPARE_SCALAR_FIELD(setof); - COMPARE_SCALAR_FIELD(pct_type); - COMPARE_NODE_FIELD(typmods); - COMPARE_SCALAR_FIELD(typemod); - COMPARE_NODE_FIELD(arrayBounds); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalTypeCast(const TypeCast *a, const TypeCast *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_NODE_FIELD(typeName); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCollateClause(const CollateClause *a, const CollateClause *b) -{ - COMPARE_NODE_FIELD(arg); - COMPARE_NODE_FIELD(collname); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalSortBy(const SortBy *a, const SortBy *b) -{ - COMPARE_NODE_FIELD(node); - COMPARE_SCALAR_FIELD(sortby_dir); - COMPARE_SCALAR_FIELD(sortby_nulls); - COMPARE_NODE_FIELD(useOp); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalWindowDef(const WindowDef *a, const WindowDef *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_STRING_FIELD(refname); - COMPARE_NODE_FIELD(partitionClause); - COMPARE_NODE_FIELD(orderClause); - COMPARE_SCALAR_FIELD(frameOptions); - COMPARE_NODE_FIELD(startOffset); - COMPARE_NODE_FIELD(endOffset); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b) -{ - COMPARE_SCALAR_FIELD(lateral); - COMPARE_NODE_FIELD(subquery); - COMPARE_NODE_FIELD(alias); - - return true; -} - -static bool -_equalRangeFunction(const RangeFunction *a, const RangeFunction *b) -{ - COMPARE_SCALAR_FIELD(lateral); - COMPARE_SCALAR_FIELD(ordinality); - COMPARE_SCALAR_FIELD(is_rowsfrom); - COMPARE_NODE_FIELD(functions); - COMPARE_NODE_FIELD(alias); - COMPARE_NODE_FIELD(coldeflist); - - return true; -} - -static bool -_equalRangeTableSample(const RangeTableSample *a, const RangeTableSample *b) -{ - COMPARE_NODE_FIELD(relation); - COMPARE_NODE_FIELD(method); - COMPARE_NODE_FIELD(args); - COMPARE_NODE_FIELD(repeatable); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalRangeTableFunc(const RangeTableFunc *a, const RangeTableFunc *b) -{ - COMPARE_SCALAR_FIELD(lateral); - COMPARE_NODE_FIELD(docexpr); - COMPARE_NODE_FIELD(rowexpr); - COMPARE_NODE_FIELD(namespaces); - COMPARE_NODE_FIELD(columns); - COMPARE_NODE_FIELD(alias); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalRangeTableFuncCol(const RangeTableFuncCol *a, const RangeTableFuncCol *b) -{ - COMPARE_STRING_FIELD(colname); - COMPARE_NODE_FIELD(typeName); - COMPARE_SCALAR_FIELD(for_ordinality); - COMPARE_SCALAR_FIELD(is_not_null); - COMPARE_NODE_FIELD(colexpr); - COMPARE_NODE_FIELD(coldefexpr); - COMPARE_LOCATION_FIELD(location); - - return true; -} - - -static bool -_equalIndexElem(const IndexElem *a, const IndexElem *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(expr); - COMPARE_STRING_FIELD(indexcolname); - COMPARE_NODE_FIELD(collation); - COMPARE_NODE_FIELD(opclass); - COMPARE_NODE_FIELD(opclassopts); - COMPARE_SCALAR_FIELD(ordering); - COMPARE_SCALAR_FIELD(nulls_ordering); - - return true; -} - - -static bool -_equalStatsElem(const StatsElem *a, const StatsElem *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(expr); - - return true; -} - -static bool -_equalColumnDef(const ColumnDef *a, const ColumnDef *b) -{ - COMPARE_STRING_FIELD(colname); - COMPARE_NODE_FIELD(typeName); - COMPARE_STRING_FIELD(compression); - COMPARE_SCALAR_FIELD(inhcount); - COMPARE_SCALAR_FIELD(is_local); - COMPARE_SCALAR_FIELD(is_not_null); - COMPARE_SCALAR_FIELD(is_from_type); - COMPARE_SCALAR_FIELD(storage); - COMPARE_NODE_FIELD(raw_default); - COMPARE_NODE_FIELD(cooked_default); - COMPARE_SCALAR_FIELD(identity); - COMPARE_NODE_FIELD(identitySequence); - COMPARE_SCALAR_FIELD(generated); - COMPARE_NODE_FIELD(collClause); - COMPARE_SCALAR_FIELD(collOid); - COMPARE_NODE_FIELD(constraints); - COMPARE_NODE_FIELD(fdwoptions); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalConstraint(const Constraint *a, const Constraint *b) -{ - COMPARE_SCALAR_FIELD(contype); - COMPARE_STRING_FIELD(conname); - COMPARE_SCALAR_FIELD(deferrable); - COMPARE_SCALAR_FIELD(initdeferred); - COMPARE_LOCATION_FIELD(location); - COMPARE_SCALAR_FIELD(is_no_inherit); - COMPARE_NODE_FIELD(raw_expr); - COMPARE_STRING_FIELD(cooked_expr); - COMPARE_SCALAR_FIELD(generated_when); - COMPARE_SCALAR_FIELD(nulls_not_distinct); - COMPARE_NODE_FIELD(keys); - COMPARE_NODE_FIELD(including); - COMPARE_NODE_FIELD(exclusions); - COMPARE_NODE_FIELD(options); - COMPARE_STRING_FIELD(indexname); - COMPARE_STRING_FIELD(indexspace); - COMPARE_SCALAR_FIELD(reset_default_tblspc); - COMPARE_STRING_FIELD(access_method); - COMPARE_NODE_FIELD(where_clause); - COMPARE_NODE_FIELD(pktable); - COMPARE_NODE_FIELD(fk_attrs); - COMPARE_NODE_FIELD(pk_attrs); - COMPARE_SCALAR_FIELD(fk_matchtype); - COMPARE_SCALAR_FIELD(fk_upd_action); - COMPARE_SCALAR_FIELD(fk_del_action); - 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); - - return true; -} - -static bool -_equalDefElem(const DefElem *a, const DefElem *b) -{ - COMPARE_STRING_FIELD(defnamespace); - COMPARE_STRING_FIELD(defname); - COMPARE_NODE_FIELD(arg); - COMPARE_SCALAR_FIELD(defaction); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalLockingClause(const LockingClause *a, const LockingClause *b) -{ - COMPARE_NODE_FIELD(lockedRels); - COMPARE_SCALAR_FIELD(strength); - COMPARE_SCALAR_FIELD(waitPolicy); - - return true; -} - -static bool -_equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b) -{ - COMPARE_SCALAR_FIELD(rtekind); - COMPARE_SCALAR_FIELD(relid); - COMPARE_SCALAR_FIELD(relkind); - COMPARE_SCALAR_FIELD(rellockmode); - COMPARE_NODE_FIELD(tablesample); - COMPARE_NODE_FIELD(subquery); - COMPARE_SCALAR_FIELD(security_barrier); - COMPARE_SCALAR_FIELD(jointype); - COMPARE_SCALAR_FIELD(joinmergedcols); - COMPARE_NODE_FIELD(joinaliasvars); - COMPARE_NODE_FIELD(joinleftcols); - COMPARE_NODE_FIELD(joinrightcols); - COMPARE_NODE_FIELD(join_using_alias); - COMPARE_NODE_FIELD(functions); - COMPARE_SCALAR_FIELD(funcordinality); - COMPARE_NODE_FIELD(tablefunc); - COMPARE_NODE_FIELD(values_lists); - COMPARE_STRING_FIELD(ctename); - COMPARE_SCALAR_FIELD(ctelevelsup); - COMPARE_SCALAR_FIELD(self_reference); - COMPARE_NODE_FIELD(coltypes); - COMPARE_NODE_FIELD(coltypmods); - 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_SCALAR_FIELD(requiredPerms); - COMPARE_SCALAR_FIELD(checkAsUser); - COMPARE_BITMAPSET_FIELD(selectedCols); - COMPARE_BITMAPSET_FIELD(insertedCols); - COMPARE_BITMAPSET_FIELD(updatedCols); - COMPARE_BITMAPSET_FIELD(extraUpdatedCols); - COMPARE_NODE_FIELD(securityQuals); - - return true; -} - -static bool -_equalRangeTblFunction(const RangeTblFunction *a, const RangeTblFunction *b) -{ - COMPARE_NODE_FIELD(funcexpr); - COMPARE_SCALAR_FIELD(funccolcount); - COMPARE_NODE_FIELD(funccolnames); - COMPARE_NODE_FIELD(funccoltypes); - COMPARE_NODE_FIELD(funccoltypmods); - COMPARE_NODE_FIELD(funccolcollations); - COMPARE_BITMAPSET_FIELD(funcparams); - - return true; -} - -static bool -_equalTableSampleClause(const TableSampleClause *a, const TableSampleClause *b) -{ - COMPARE_SCALAR_FIELD(tsmhandler); - COMPARE_NODE_FIELD(args); - COMPARE_NODE_FIELD(repeatable); - - return true; -} - -static bool -_equalWithCheckOption(const WithCheckOption *a, const WithCheckOption *b) -{ - COMPARE_SCALAR_FIELD(kind); - COMPARE_STRING_FIELD(relname); - COMPARE_STRING_FIELD(polname); - COMPARE_NODE_FIELD(qual); - COMPARE_SCALAR_FIELD(cascaded); - - return true; -} - -static bool -_equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b) -{ - COMPARE_SCALAR_FIELD(tleSortGroupRef); - COMPARE_SCALAR_FIELD(eqop); - COMPARE_SCALAR_FIELD(sortop); - COMPARE_SCALAR_FIELD(nulls_first); - COMPARE_SCALAR_FIELD(hashable); - - return true; -} - -static bool -_equalGroupingSet(const GroupingSet *a, const GroupingSet *b) -{ - COMPARE_SCALAR_FIELD(kind); - COMPARE_NODE_FIELD(content); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalWindowClause(const WindowClause *a, const WindowClause *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_STRING_FIELD(refname); - COMPARE_NODE_FIELD(partitionClause); - COMPARE_NODE_FIELD(orderClause); - 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); - COMPARE_SCALAR_FIELD(inRangeAsc); - COMPARE_SCALAR_FIELD(inRangeNullsFirst); - COMPARE_SCALAR_FIELD(winref); - COMPARE_SCALAR_FIELD(copiedOrder); - - return true; -} - -static bool -_equalRowMarkClause(const RowMarkClause *a, const RowMarkClause *b) -{ - COMPARE_SCALAR_FIELD(rti); - COMPARE_SCALAR_FIELD(strength); - COMPARE_SCALAR_FIELD(waitPolicy); - COMPARE_SCALAR_FIELD(pushedDown); - - return true; -} - -static bool -_equalWithClause(const WithClause *a, const WithClause *b) -{ - COMPARE_NODE_FIELD(ctes); - COMPARE_SCALAR_FIELD(recursive); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalInferClause(const InferClause *a, const InferClause *b) -{ - COMPARE_NODE_FIELD(indexElems); - COMPARE_NODE_FIELD(whereClause); - COMPARE_STRING_FIELD(conname); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalOnConflictClause(const OnConflictClause *a, const OnConflictClause *b) -{ - COMPARE_SCALAR_FIELD(action); - COMPARE_NODE_FIELD(infer); - COMPARE_NODE_FIELD(targetList); - COMPARE_NODE_FIELD(whereClause); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCTESearchClause(const CTESearchClause *a, const CTESearchClause *b) -{ - COMPARE_NODE_FIELD(search_col_list); - COMPARE_SCALAR_FIELD(search_breadth_first); - COMPARE_STRING_FIELD(search_seq_column); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalCTECycleClause(const CTECycleClause *a, const CTECycleClause *b) -{ - COMPARE_NODE_FIELD(cycle_col_list); - COMPARE_STRING_FIELD(cycle_mark_column); - COMPARE_NODE_FIELD(cycle_mark_value); - COMPARE_NODE_FIELD(cycle_mark_default); - COMPARE_STRING_FIELD(cycle_path_column); - COMPARE_LOCATION_FIELD(location); - COMPARE_SCALAR_FIELD(cycle_mark_type); - COMPARE_SCALAR_FIELD(cycle_mark_typmod); - COMPARE_SCALAR_FIELD(cycle_mark_collation); - COMPARE_SCALAR_FIELD(cycle_mark_neop); - - return true; -} - -static bool -_equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b) -{ - COMPARE_STRING_FIELD(ctename); - COMPARE_NODE_FIELD(aliascolnames); - COMPARE_SCALAR_FIELD(ctematerialized); - COMPARE_NODE_FIELD(ctequery); - COMPARE_NODE_FIELD(search_clause); - COMPARE_NODE_FIELD(cycle_clause); - COMPARE_LOCATION_FIELD(location); - COMPARE_SCALAR_FIELD(cterecursive); - COMPARE_SCALAR_FIELD(cterefcount); - COMPARE_NODE_FIELD(ctecolnames); - COMPARE_NODE_FIELD(ctecoltypes); - COMPARE_NODE_FIELD(ctecoltypmods); - COMPARE_NODE_FIELD(ctecolcollations); - - return true; -} - -static bool -_equalMergeWhenClause(const MergeWhenClause *a, const MergeWhenClause *b) -{ - COMPARE_SCALAR_FIELD(matched); - COMPARE_SCALAR_FIELD(commandType); - COMPARE_SCALAR_FIELD(override); - COMPARE_NODE_FIELD(condition); - COMPARE_NODE_FIELD(targetList); - COMPARE_NODE_FIELD(values); - - return true; -} - -static bool -_equalMergeAction(const MergeAction *a, const MergeAction *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); - - return true; -} - -static bool -_equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b) -{ - COMPARE_SCALAR_FIELD(xmloption); - COMPARE_NODE_FIELD(expr); - COMPARE_NODE_FIELD(typeName); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalRoleSpec(const RoleSpec *a, const RoleSpec *b) -{ - COMPARE_SCALAR_FIELD(roletype); - COMPARE_STRING_FIELD(rolename); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalTriggerTransition(const TriggerTransition *a, const TriggerTransition *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_SCALAR_FIELD(isNew); - COMPARE_SCALAR_FIELD(isTable); - - return true; -} - -static bool -_equalPartitionElem(const PartitionElem *a, const PartitionElem *b) -{ - COMPARE_STRING_FIELD(name); - COMPARE_NODE_FIELD(expr); - COMPARE_NODE_FIELD(collation); - COMPARE_NODE_FIELD(opclass); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalPartitionSpec(const PartitionSpec *a, const PartitionSpec *b) -{ - COMPARE_STRING_FIELD(strategy); - COMPARE_NODE_FIELD(partParams); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalPartitionBoundSpec(const PartitionBoundSpec *a, const PartitionBoundSpec *b) -{ - COMPARE_SCALAR_FIELD(strategy); - COMPARE_SCALAR_FIELD(is_default); - COMPARE_SCALAR_FIELD(modulus); - COMPARE_SCALAR_FIELD(remainder); - COMPARE_NODE_FIELD(listdatums); - COMPARE_NODE_FIELD(lowerdatums); - COMPARE_NODE_FIELD(upperdatums); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalPartitionRangeDatum(const PartitionRangeDatum *a, const PartitionRangeDatum *b) -{ - COMPARE_SCALAR_FIELD(kind); - COMPARE_NODE_FIELD(value); - COMPARE_LOCATION_FIELD(location); - - return true; -} - -static bool -_equalPartitionCmd(const PartitionCmd *a, const PartitionCmd *b) -{ - COMPARE_NODE_FIELD(name); - COMPARE_NODE_FIELD(bound); - COMPARE_SCALAR_FIELD(concurrent); - - return true; -} -#endif /* OBSOLETE */ - /* - * Stuff from pg_list.h + * Lists are handled specially */ - static bool _equalList(const List *a, const List *b) { @@ -3533,51 +203,6 @@ _equalList(const List *a, const List *b) return true; } -#ifdef OBSOLETE -/* - * Stuff from value.h - */ - -static bool -_equalInteger(const Integer *a, const Integer *b) -{ - COMPARE_SCALAR_FIELD(ival); - - return true; -} - -static bool -_equalFloat(const Float *a, const Float *b) -{ - COMPARE_STRING_FIELD(fval); - - return true; -} - -static bool -_equalBoolean(const Boolean *a, const Boolean *b) -{ - COMPARE_SCALAR_FIELD(boolval); - - return true; -} - -static bool -_equalString(const String *a, const String *b) -{ - COMPARE_STRING_FIELD(sval); - - return true; -} - -static bool -_equalBitString(const BitString *a, const BitString *b) -{ - COMPARE_STRING_FIELD(bsval); - - return true; -} -#endif /* OBSOLETE */ /* * equal @@ -3609,228 +234,6 @@ equal(const void *a, const void *b) switch (nodeTag(a)) { #include "equalfuncs.switch.c" -#ifdef OBSOLETE - /* - * PRIMITIVE NODES - */ - case T_Alias: - retval = _equalAlias(a, b); - break; - case T_RangeVar: - retval = _equalRangeVar(a, b); - break; - case T_TableFunc: - retval = _equalTableFunc(a, b); - break; - case T_IntoClause: - retval = _equalIntoClause(a, b); - break; - case T_Var: - retval = _equalVar(a, b); - break; - case T_Const: - retval = _equalConst(a, b); - break; - case T_Param: - retval = _equalParam(a, b); - break; - case T_Aggref: - retval = _equalAggref(a, b); - break; - case T_GroupingFunc: - retval = _equalGroupingFunc(a, b); - break; - case T_WindowFunc: - retval = _equalWindowFunc(a, b); - break; - case T_SubscriptingRef: - retval = _equalSubscriptingRef(a, b); - break; - case T_FuncExpr: - retval = _equalFuncExpr(a, b); - break; - case T_NamedArgExpr: - retval = _equalNamedArgExpr(a, b); - break; - case T_OpExpr: - retval = _equalOpExpr(a, b); - break; - case T_DistinctExpr: - retval = _equalDistinctExpr(a, b); - break; - case T_NullIfExpr: - retval = _equalNullIfExpr(a, b); - break; - case T_ScalarArrayOpExpr: - retval = _equalScalarArrayOpExpr(a, b); - break; - case T_BoolExpr: - retval = _equalBoolExpr(a, b); - break; - case T_SubLink: - retval = _equalSubLink(a, b); - break; - case T_SubPlan: - retval = _equalSubPlan(a, b); - break; - case T_AlternativeSubPlan: - retval = _equalAlternativeSubPlan(a, b); - break; - case T_FieldSelect: - retval = _equalFieldSelect(a, b); - break; - case T_FieldStore: - retval = _equalFieldStore(a, b); - break; - case T_RelabelType: - retval = _equalRelabelType(a, b); - break; - case T_CoerceViaIO: - retval = _equalCoerceViaIO(a, b); - break; - case T_ArrayCoerceExpr: - retval = _equalArrayCoerceExpr(a, b); - break; - case T_ConvertRowtypeExpr: - retval = _equalConvertRowtypeExpr(a, b); - break; - case T_CollateExpr: - retval = _equalCollateExpr(a, b); - break; - case T_CaseExpr: - retval = _equalCaseExpr(a, b); - break; - case T_CaseWhen: - retval = _equalCaseWhen(a, b); - break; - case T_CaseTestExpr: - retval = _equalCaseTestExpr(a, b); - break; - case T_ArrayExpr: - retval = _equalArrayExpr(a, b); - break; - case T_RowExpr: - retval = _equalRowExpr(a, b); - break; - case T_RowCompareExpr: - retval = _equalRowCompareExpr(a, b); - break; - case T_CoalesceExpr: - retval = _equalCoalesceExpr(a, b); - break; - case T_MinMaxExpr: - retval = _equalMinMaxExpr(a, b); - break; - case T_SQLValueFunction: - retval = _equalSQLValueFunction(a, b); - break; - case T_XmlExpr: - retval = _equalXmlExpr(a, b); - break; - case T_NullTest: - retval = _equalNullTest(a, b); - break; - case T_BooleanTest: - retval = _equalBooleanTest(a, b); - break; - case T_CoerceToDomain: - retval = _equalCoerceToDomain(a, b); - break; - case T_CoerceToDomainValue: - retval = _equalCoerceToDomainValue(a, b); - break; - case T_SetToDefault: - retval = _equalSetToDefault(a, b); - break; - case T_CurrentOfExpr: - retval = _equalCurrentOfExpr(a, b); - break; - case T_NextValueExpr: - retval = _equalNextValueExpr(a, b); - break; - case T_InferenceElem: - retval = _equalInferenceElem(a, b); - break; - case T_TargetEntry: - retval = _equalTargetEntry(a, b); - break; - case T_RangeTblRef: - retval = _equalRangeTblRef(a, b); - break; - case T_FromExpr: - retval = _equalFromExpr(a, b); - break; - case T_OnConflictExpr: - retval = _equalOnConflictExpr(a, b); - break; - case T_JoinExpr: - retval = _equalJoinExpr(a, b); - break; - case T_JsonFormat: - retval = _equalJsonFormat(a, b); - break; - case T_JsonReturning: - retval = _equalJsonReturning(a, b); - break; - case T_JsonValueExpr: - retval = _equalJsonValueExpr(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_JsonConstructorExpr: - retval = _equalJsonConstructorExpr(a, b); - break; - 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_JsonCoercion: - retval = _equalJsonCoercion(a, b); - break; - case T_JsonItemCoercions: - retval = _equalJsonItemCoercions(a, b); - break; - case T_JsonTableParent: - retval = _equalJsonTableParent(a, b); - break; - case T_JsonTableSibling: - retval = _equalJsonTableSibling(a, b); - break; - - /* - * RELATION NODES - */ - case T_PathKey: - retval = _equalPathKey(a, b); - break; - case T_RestrictInfo: - retval = _equalRestrictInfo(a, b); - break; - case T_PlaceHolderVar: - retval = _equalPlaceHolderVar(a, b); - break; - case T_SpecialJoinInfo: - retval = _equalSpecialJoinInfo(a, b); - break; - case T_AppendRelInfo: - retval = _equalAppendRelInfo(a, b); - break; - case T_PlaceHolderInfo: - retval = _equalPlaceHolderInfo(a, b); - break; -#endif /* OBSOLETE */ case T_List: case T_IntList: @@ -3838,611 +241,6 @@ equal(const void *a, const void *b) retval = _equalList(a, b); break; -#ifdef OBSOLETE - case T_Integer: - retval = _equalInteger(a, b); - break; - case T_Float: - retval = _equalFloat(a, b); - break; - case T_Boolean: - retval = _equalBoolean(a, b); - break; - case T_String: - retval = _equalString(a, b); - break; - case T_BitString: - retval = _equalBitString(a, b); - break; - - /* - * EXTENSIBLE NODES - */ - case T_ExtensibleNode: - retval = _equalExtensibleNode(a, b); - break; - - /* - * PARSE NODES - */ - case T_Query: - retval = _equalQuery(a, b); - break; - case T_RawStmt: - retval = _equalRawStmt(a, b); - break; - case T_InsertStmt: - retval = _equalInsertStmt(a, b); - break; - case T_DeleteStmt: - retval = _equalDeleteStmt(a, b); - break; - case T_UpdateStmt: - retval = _equalUpdateStmt(a, b); - break; - case T_MergeStmt: - retval = _equalMergeStmt(a, b); - break; - case T_SelectStmt: - retval = _equalSelectStmt(a, b); - break; - case T_SetOperationStmt: - retval = _equalSetOperationStmt(a, b); - break; - case T_ReturnStmt: - retval = _equalReturnStmt(a, b); - break; - case T_PLAssignStmt: - retval = _equalPLAssignStmt(a, b); - break; - case T_AlterTableStmt: - retval = _equalAlterTableStmt(a, b); - break; - case T_AlterTableCmd: - retval = _equalAlterTableCmd(a, b); - break; - case T_AlterCollationStmt: - retval = _equalAlterCollationStmt(a, b); - break; - case T_AlterDomainStmt: - retval = _equalAlterDomainStmt(a, b); - break; - case T_GrantStmt: - retval = _equalGrantStmt(a, b); - break; - case T_GrantRoleStmt: - retval = _equalGrantRoleStmt(a, b); - break; - case T_AlterDefaultPrivilegesStmt: - retval = _equalAlterDefaultPrivilegesStmt(a, b); - break; - case T_DeclareCursorStmt: - retval = _equalDeclareCursorStmt(a, b); - break; - case T_ClosePortalStmt: - retval = _equalClosePortalStmt(a, b); - break; - case T_CallStmt: - retval = _equalCallStmt(a, b); - break; - case T_ClusterStmt: - retval = _equalClusterStmt(a, b); - break; - case T_CopyStmt: - retval = _equalCopyStmt(a, b); - break; - case T_CreateStmt: - retval = _equalCreateStmt(a, b); - break; - case T_TableLikeClause: - retval = _equalTableLikeClause(a, b); - break; - case T_DefineStmt: - retval = _equalDefineStmt(a, b); - break; - case T_DropStmt: - retval = _equalDropStmt(a, b); - break; - case T_TruncateStmt: - retval = _equalTruncateStmt(a, b); - break; - case T_CommentStmt: - retval = _equalCommentStmt(a, b); - break; - case T_SecLabelStmt: - retval = _equalSecLabelStmt(a, b); - break; - case T_FetchStmt: - retval = _equalFetchStmt(a, b); - break; - case T_IndexStmt: - retval = _equalIndexStmt(a, b); - break; - case T_CreateStatsStmt: - retval = _equalCreateStatsStmt(a, b); - break; - case T_AlterStatsStmt: - retval = _equalAlterStatsStmt(a, b); - break; - case T_CreateFunctionStmt: - retval = _equalCreateFunctionStmt(a, b); - break; - case T_FunctionParameter: - retval = _equalFunctionParameter(a, b); - break; - case T_AlterFunctionStmt: - retval = _equalAlterFunctionStmt(a, b); - break; - case T_DoStmt: - retval = _equalDoStmt(a, b); - break; - case T_RenameStmt: - retval = _equalRenameStmt(a, b); - break; - case T_AlterObjectDependsStmt: - retval = _equalAlterObjectDependsStmt(a, b); - break; - case T_AlterObjectSchemaStmt: - retval = _equalAlterObjectSchemaStmt(a, b); - break; - case T_AlterOwnerStmt: - retval = _equalAlterOwnerStmt(a, b); - break; - case T_AlterOperatorStmt: - retval = _equalAlterOperatorStmt(a, b); - break; - case T_AlterTypeStmt: - retval = _equalAlterTypeStmt(a, b); - break; - case T_RuleStmt: - retval = _equalRuleStmt(a, b); - break; - case T_NotifyStmt: - retval = _equalNotifyStmt(a, b); - break; - case T_ListenStmt: - retval = _equalListenStmt(a, b); - break; - case T_UnlistenStmt: - retval = _equalUnlistenStmt(a, b); - break; - case T_TransactionStmt: - retval = _equalTransactionStmt(a, b); - break; - case T_CompositeTypeStmt: - retval = _equalCompositeTypeStmt(a, b); - break; - case T_CreateEnumStmt: - retval = _equalCreateEnumStmt(a, b); - break; - case T_CreateRangeStmt: - retval = _equalCreateRangeStmt(a, b); - break; - case T_AlterEnumStmt: - retval = _equalAlterEnumStmt(a, b); - break; - case T_ViewStmt: - retval = _equalViewStmt(a, b); - break; - case T_LoadStmt: - retval = _equalLoadStmt(a, b); - break; - case T_CreateDomainStmt: - retval = _equalCreateDomainStmt(a, b); - break; - case T_CreateOpClassStmt: - retval = _equalCreateOpClassStmt(a, b); - break; - case T_CreateOpClassItem: - retval = _equalCreateOpClassItem(a, b); - break; - case T_CreateOpFamilyStmt: - retval = _equalCreateOpFamilyStmt(a, b); - break; - case T_AlterOpFamilyStmt: - retval = _equalAlterOpFamilyStmt(a, b); - break; - case T_CreatedbStmt: - retval = _equalCreatedbStmt(a, b); - break; - case T_AlterDatabaseStmt: - retval = _equalAlterDatabaseStmt(a, b); - break; - case T_AlterDatabaseRefreshCollStmt: - retval = _equalAlterDatabaseRefreshCollStmt(a, b); - break; - case T_AlterDatabaseSetStmt: - retval = _equalAlterDatabaseSetStmt(a, b); - break; - case T_DropdbStmt: - retval = _equalDropdbStmt(a, b); - break; - case T_VacuumStmt: - retval = _equalVacuumStmt(a, b); - break; - case T_VacuumRelation: - retval = _equalVacuumRelation(a, b); - break; - case T_ExplainStmt: - retval = _equalExplainStmt(a, b); - break; - case T_CreateTableAsStmt: - retval = _equalCreateTableAsStmt(a, b); - break; - case T_RefreshMatViewStmt: - retval = _equalRefreshMatViewStmt(a, b); - break; - case T_ReplicaIdentityStmt: - retval = _equalReplicaIdentityStmt(a, b); - break; - case T_AlterSystemStmt: - retval = _equalAlterSystemStmt(a, b); - break; - case T_CreateSeqStmt: - retval = _equalCreateSeqStmt(a, b); - break; - case T_AlterSeqStmt: - retval = _equalAlterSeqStmt(a, b); - break; - case T_VariableSetStmt: - retval = _equalVariableSetStmt(a, b); - break; - case T_VariableShowStmt: - retval = _equalVariableShowStmt(a, b); - break; - case T_DiscardStmt: - retval = _equalDiscardStmt(a, b); - break; - case T_CreateTableSpaceStmt: - retval = _equalCreateTableSpaceStmt(a, b); - break; - case T_DropTableSpaceStmt: - retval = _equalDropTableSpaceStmt(a, b); - break; - case T_AlterTableSpaceOptionsStmt: - retval = _equalAlterTableSpaceOptionsStmt(a, b); - break; - case T_AlterTableMoveAllStmt: - retval = _equalAlterTableMoveAllStmt(a, b); - break; - case T_CreateExtensionStmt: - retval = _equalCreateExtensionStmt(a, b); - break; - case T_AlterExtensionStmt: - retval = _equalAlterExtensionStmt(a, b); - break; - case T_AlterExtensionContentsStmt: - retval = _equalAlterExtensionContentsStmt(a, b); - break; - case T_CreateFdwStmt: - retval = _equalCreateFdwStmt(a, b); - break; - case T_AlterFdwStmt: - retval = _equalAlterFdwStmt(a, b); - break; - case T_CreateForeignServerStmt: - retval = _equalCreateForeignServerStmt(a, b); - break; - case T_AlterForeignServerStmt: - retval = _equalAlterForeignServerStmt(a, b); - break; - case T_CreateUserMappingStmt: - retval = _equalCreateUserMappingStmt(a, b); - break; - case T_AlterUserMappingStmt: - retval = _equalAlterUserMappingStmt(a, b); - break; - case T_DropUserMappingStmt: - retval = _equalDropUserMappingStmt(a, b); - break; - case T_CreateForeignTableStmt: - retval = _equalCreateForeignTableStmt(a, b); - break; - case T_ImportForeignSchemaStmt: - retval = _equalImportForeignSchemaStmt(a, b); - break; - case T_CreateTransformStmt: - retval = _equalCreateTransformStmt(a, b); - break; - case T_CreateAmStmt: - retval = _equalCreateAmStmt(a, b); - break; - case T_CreateTrigStmt: - retval = _equalCreateTrigStmt(a, b); - break; - case T_CreateEventTrigStmt: - retval = _equalCreateEventTrigStmt(a, b); - break; - case T_AlterEventTrigStmt: - retval = _equalAlterEventTrigStmt(a, b); - break; - case T_CreatePLangStmt: - retval = _equalCreatePLangStmt(a, b); - break; - case T_CreateRoleStmt: - retval = _equalCreateRoleStmt(a, b); - break; - case T_AlterRoleStmt: - retval = _equalAlterRoleStmt(a, b); - break; - case T_AlterRoleSetStmt: - retval = _equalAlterRoleSetStmt(a, b); - break; - case T_DropRoleStmt: - retval = _equalDropRoleStmt(a, b); - break; - case T_LockStmt: - retval = _equalLockStmt(a, b); - break; - case T_ConstraintsSetStmt: - retval = _equalConstraintsSetStmt(a, b); - break; - case T_ReindexStmt: - retval = _equalReindexStmt(a, b); - break; - case T_CheckPointStmt: - retval = true; - break; - case T_CreateSchemaStmt: - retval = _equalCreateSchemaStmt(a, b); - break; - case T_CreateConversionStmt: - retval = _equalCreateConversionStmt(a, b); - break; - case T_CreateCastStmt: - retval = _equalCreateCastStmt(a, b); - break; - case T_PrepareStmt: - retval = _equalPrepareStmt(a, b); - break; - case T_ExecuteStmt: - retval = _equalExecuteStmt(a, b); - break; - case T_DeallocateStmt: - retval = _equalDeallocateStmt(a, b); - break; - case T_DropOwnedStmt: - retval = _equalDropOwnedStmt(a, b); - break; - case T_ReassignOwnedStmt: - retval = _equalReassignOwnedStmt(a, b); - break; - case T_AlterTSDictionaryStmt: - retval = _equalAlterTSDictionaryStmt(a, b); - break; - case T_AlterTSConfigurationStmt: - retval = _equalAlterTSConfigurationStmt(a, b); - break; - case T_CreatePolicyStmt: - retval = _equalCreatePolicyStmt(a, b); - break; - case T_AlterPolicyStmt: - retval = _equalAlterPolicyStmt(a, b); - break; - case T_CreatePublicationStmt: - retval = _equalCreatePublicationStmt(a, b); - break; - case T_AlterPublicationStmt: - retval = _equalAlterPublicationStmt(a, b); - break; - case T_CreateSubscriptionStmt: - retval = _equalCreateSubscriptionStmt(a, b); - break; - case T_AlterSubscriptionStmt: - retval = _equalAlterSubscriptionStmt(a, b); - break; - case T_DropSubscriptionStmt: - retval = _equalDropSubscriptionStmt(a, b); - break; - case T_A_Expr: - retval = _equalA_Expr(a, b); - break; - case T_ColumnRef: - retval = _equalColumnRef(a, b); - break; - case T_ParamRef: - retval = _equalParamRef(a, b); - break; - case T_A_Const: - retval = _equalA_Const(a, b); - break; - case T_FuncCall: - retval = _equalFuncCall(a, b); - break; - case T_A_Star: - retval = _equalA_Star(a, b); - break; - case T_A_Indices: - retval = _equalA_Indices(a, b); - break; - case T_A_Indirection: - retval = _equalA_Indirection(a, b); - break; - case T_A_ArrayExpr: - retval = _equalA_ArrayExpr(a, b); - break; - case T_ResTarget: - retval = _equalResTarget(a, b); - break; - case T_MultiAssignRef: - retval = _equalMultiAssignRef(a, b); - break; - case T_TypeCast: - retval = _equalTypeCast(a, b); - break; - case T_CollateClause: - retval = _equalCollateClause(a, b); - break; - case T_SortBy: - retval = _equalSortBy(a, b); - break; - case T_WindowDef: - retval = _equalWindowDef(a, b); - break; - case T_RangeSubselect: - retval = _equalRangeSubselect(a, b); - break; - case T_RangeFunction: - retval = _equalRangeFunction(a, b); - break; - case T_RangeTableSample: - retval = _equalRangeTableSample(a, b); - break; - case T_RangeTableFunc: - retval = _equalRangeTableFunc(a, b); - break; - case T_RangeTableFuncCol: - retval = _equalRangeTableFuncCol(a, b); - break; - case T_TypeName: - retval = _equalTypeName(a, b); - break; - case T_IndexElem: - retval = _equalIndexElem(a, b); - break; - case T_StatsElem: - retval = _equalStatsElem(a, b); - break; - case T_ColumnDef: - retval = _equalColumnDef(a, b); - break; - case T_Constraint: - retval = _equalConstraint(a, b); - break; - case T_DefElem: - retval = _equalDefElem(a, b); - break; - case T_LockingClause: - retval = _equalLockingClause(a, b); - break; - case T_RangeTblEntry: - retval = _equalRangeTblEntry(a, b); - break; - case T_RangeTblFunction: - retval = _equalRangeTblFunction(a, b); - break; - case T_TableSampleClause: - retval = _equalTableSampleClause(a, b); - break; - case T_WithCheckOption: - retval = _equalWithCheckOption(a, b); - break; - case T_SortGroupClause: - retval = _equalSortGroupClause(a, b); - break; - case T_GroupingSet: - retval = _equalGroupingSet(a, b); - break; - case T_WindowClause: - retval = _equalWindowClause(a, b); - break; - case T_RowMarkClause: - retval = _equalRowMarkClause(a, b); - break; - case T_WithClause: - retval = _equalWithClause(a, b); - break; - case T_InferClause: - retval = _equalInferClause(a, b); - break; - case T_OnConflictClause: - retval = _equalOnConflictClause(a, b); - break; - case T_CTESearchClause: - retval = _equalCTESearchClause(a, b); - break; - case T_CTECycleClause: - retval = _equalCTECycleClause(a, b); - break; - case T_CommonTableExpr: - retval = _equalCommonTableExpr(a, b); - break; - case T_MergeWhenClause: - retval = _equalMergeWhenClause(a, b); - break; - case T_MergeAction: - retval = _equalMergeAction(a, b); - break; - case T_ObjectWithArgs: - retval = _equalObjectWithArgs(a, b); - break; - case T_AccessPriv: - retval = _equalAccessPriv(a, b); - break; - case T_XmlSerialize: - retval = _equalXmlSerialize(a, b); - break; - case T_RoleSpec: - retval = _equalRoleSpec(a, b); - break; - case T_TriggerTransition: - retval = _equalTriggerTransition(a, b); - break; - case T_PartitionElem: - retval = _equalPartitionElem(a, b); - break; - case T_PartitionSpec: - retval = _equalPartitionSpec(a, b); - break; - case T_PartitionBoundSpec: - retval = _equalPartitionBoundSpec(a, b); - break; - case T_PartitionRangeDatum: - retval = _equalPartitionRangeDatum(a, b); - break; - case T_PartitionCmd: - retval = _equalPartitionCmd(a, b); - break; - case T_PublicationObjSpec: - retval = _equalPublicationObject(a, b); - break; - case T_PublicationTable: - retval = _equalPublicationTable(a, b); - break; - case T_JsonKeyValue: - retval = _equalJsonKeyValue(a, b); - break; - case T_JsonObjectConstructor: - retval = _equalJsonObjectConstructor(a, b); - break; - case T_JsonAggConstructor: - retval = _equalJsonAggConstructor(a, b); - break; - case T_JsonObjectAgg: - retval = _equalJsonObjectAgg(a, b); - break; - case T_JsonOutput: - retval = _equalJsonOutput(a, b); - break; - case T_JsonArrayConstructor: - retval = _equalJsonArrayConstructor(a, b); - break; - case T_JsonArrayQueryConstructor: - retval = _equalJsonArrayQueryConstructor(a, b); - break; - case T_JsonArrayAgg: - retval = _equalJsonArrayAgg(a, b); - break; - case T_JsonFuncExpr: - retval = _equalJsonFuncExpr(a, b); - break; - case T_JsonCommon: - retval = _equalJsonCommon(a, b); - break; - case T_JsonArgument: - retval = _equalJsonArgument(a, b); - break; - case T_JsonTablePlan: - retval = _equalJsonTablePlan(a, b); - break; - case T_JsonTable: - retval = _equalJsonTable(a, b); - break; - case T_JsonTableColumn: - retval = _equalJsonTableColumn(a, b); - break; -#endif /* OBSOLETE */ - default: elog(ERROR, "unrecognized node type: %d", (int) nodeTag(a)); diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index f26c129d59..9e70bbb4d6 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -307,840 +307,11 @@ outDatum(StringInfo str, Datum value, int typlen, bool typbyval) #include "outfuncs.funcs.c" -#ifdef OBSOLETE -/* - * Stuff from plannodes.h - */ - -static void -_outPlannedStmt(StringInfo str, const PlannedStmt *node) -{ - WRITE_NODE_TYPE("PLANNEDSTMT"); - - WRITE_ENUM_FIELD(commandType, CmdType); - WRITE_UINT64_FIELD(queryId); - WRITE_BOOL_FIELD(hasReturning); - WRITE_BOOL_FIELD(hasModifyingCTE); - WRITE_BOOL_FIELD(canSetTag); - WRITE_BOOL_FIELD(transientPlan); - WRITE_BOOL_FIELD(dependsOnRole); - WRITE_BOOL_FIELD(parallelModeNeeded); - WRITE_INT_FIELD(jitFlags); - WRITE_NODE_FIELD(planTree); - WRITE_NODE_FIELD(rtable); - WRITE_NODE_FIELD(resultRelations); - WRITE_NODE_FIELD(appendRelations); - WRITE_NODE_FIELD(subplans); - WRITE_BITMAPSET_FIELD(rewindPlanIDs); - WRITE_NODE_FIELD(rowMarks); - WRITE_NODE_FIELD(relationOids); - WRITE_NODE_FIELD(invalItems); - WRITE_NODE_FIELD(paramExecTypes); - WRITE_NODE_FIELD(utilityStmt); - WRITE_LOCATION_FIELD(stmt_location); - WRITE_INT_FIELD(stmt_len); -} /* - * print the basic stuff of all nodes that inherit from Plan + * Support functions for nodes with custom_read_write attribute or + * special_read_write attribute */ -static void -_outPlanInfo(StringInfo str, const Plan *node) -{ - WRITE_FLOAT_FIELD(startup_cost, "%.2f"); - WRITE_FLOAT_FIELD(total_cost, "%.2f"); - WRITE_FLOAT_FIELD(plan_rows, "%.0f"); - WRITE_INT_FIELD(plan_width); - WRITE_BOOL_FIELD(parallel_aware); - WRITE_BOOL_FIELD(parallel_safe); - WRITE_BOOL_FIELD(async_capable); - WRITE_INT_FIELD(plan_node_id); - WRITE_NODE_FIELD(targetlist); - WRITE_NODE_FIELD(qual); - WRITE_NODE_FIELD(lefttree); - WRITE_NODE_FIELD(righttree); - WRITE_NODE_FIELD(initPlan); - WRITE_BITMAPSET_FIELD(extParam); - WRITE_BITMAPSET_FIELD(allParam); -} - -/* - * print the basic stuff of all nodes that inherit from Scan - */ -static void -_outScanInfo(StringInfo str, const Scan *node) -{ - _outPlanInfo(str, (const Plan *) node); - - WRITE_UINT_FIELD(scanrelid); -} - -/* - * print the basic stuff of all nodes that inherit from Join - */ -static void -_outJoinPlanInfo(StringInfo str, const Join *node) -{ - _outPlanInfo(str, (const Plan *) node); - - WRITE_ENUM_FIELD(jointype, JoinType); - WRITE_BOOL_FIELD(inner_unique); - WRITE_NODE_FIELD(joinqual); -} - -static void -_outResult(StringInfo str, const Result *node) -{ - WRITE_NODE_TYPE("RESULT"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_NODE_FIELD(resconstantqual); -} - -static void -_outProjectSet(StringInfo str, const ProjectSet *node) -{ - WRITE_NODE_TYPE("PROJECTSET"); - - _outPlanInfo(str, (const Plan *) node); -} - -static void -_outModifyTable(StringInfo str, const ModifyTable *node) -{ - WRITE_NODE_TYPE("MODIFYTABLE"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_ENUM_FIELD(operation, CmdType); - WRITE_BOOL_FIELD(canSetTag); - WRITE_UINT_FIELD(nominalRelation); - WRITE_UINT_FIELD(rootRelation); - WRITE_BOOL_FIELD(partColsUpdated); - WRITE_NODE_FIELD(resultRelations); - WRITE_NODE_FIELD(updateColnosLists); - WRITE_NODE_FIELD(withCheckOptionLists); - WRITE_NODE_FIELD(returningLists); - WRITE_NODE_FIELD(fdwPrivLists); - WRITE_BITMAPSET_FIELD(fdwDirectModifyPlans); - WRITE_NODE_FIELD(rowMarks); - WRITE_INT_FIELD(epqParam); - WRITE_ENUM_FIELD(onConflictAction, OnConflictAction); - WRITE_NODE_FIELD(arbiterIndexes); - WRITE_NODE_FIELD(onConflictSet); - WRITE_NODE_FIELD(onConflictCols); - WRITE_NODE_FIELD(onConflictWhere); - WRITE_UINT_FIELD(exclRelRTI); - WRITE_NODE_FIELD(exclRelTlist); - WRITE_NODE_FIELD(mergeActionLists); -} - -static void -_outAppend(StringInfo str, const Append *node) -{ - WRITE_NODE_TYPE("APPEND"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_BITMAPSET_FIELD(apprelids); - WRITE_NODE_FIELD(appendplans); - WRITE_INT_FIELD(nasyncplans); - WRITE_INT_FIELD(first_partial_plan); - WRITE_NODE_FIELD(part_prune_info); -} - -static void -_outMergeAppend(StringInfo str, const MergeAppend *node) -{ - WRITE_NODE_TYPE("MERGEAPPEND"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_BITMAPSET_FIELD(apprelids); - WRITE_NODE_FIELD(mergeplans); - WRITE_INT_FIELD(numCols); - WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols); - WRITE_OID_ARRAY(sortOperators, node->numCols); - WRITE_OID_ARRAY(collations, node->numCols); - WRITE_BOOL_ARRAY(nullsFirst, node->numCols); - WRITE_NODE_FIELD(part_prune_info); -} - -static void -_outRecursiveUnion(StringInfo str, const RecursiveUnion *node) -{ - WRITE_NODE_TYPE("RECURSIVEUNION"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_INT_FIELD(wtParam); - WRITE_INT_FIELD(numCols); - WRITE_ATTRNUMBER_ARRAY(dupColIdx, node->numCols); - WRITE_OID_ARRAY(dupOperators, node->numCols); - WRITE_OID_ARRAY(dupCollations, node->numCols); - WRITE_LONG_FIELD(numGroups); -} - -static void -_outBitmapAnd(StringInfo str, const BitmapAnd *node) -{ - WRITE_NODE_TYPE("BITMAPAND"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_NODE_FIELD(bitmapplans); -} - -static void -_outBitmapOr(StringInfo str, const BitmapOr *node) -{ - WRITE_NODE_TYPE("BITMAPOR"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_BOOL_FIELD(isshared); - WRITE_NODE_FIELD(bitmapplans); -} - -static void -_outGather(StringInfo str, const Gather *node) -{ - WRITE_NODE_TYPE("GATHER"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_INT_FIELD(num_workers); - WRITE_INT_FIELD(rescan_param); - WRITE_BOOL_FIELD(single_copy); - WRITE_BOOL_FIELD(invisible); - WRITE_BITMAPSET_FIELD(initParam); -} - -static void -_outGatherMerge(StringInfo str, const GatherMerge *node) -{ - WRITE_NODE_TYPE("GATHERMERGE"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_INT_FIELD(num_workers); - WRITE_INT_FIELD(rescan_param); - WRITE_INT_FIELD(numCols); - WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols); - WRITE_OID_ARRAY(sortOperators, node->numCols); - WRITE_OID_ARRAY(collations, node->numCols); - WRITE_BOOL_ARRAY(nullsFirst, node->numCols); - WRITE_BITMAPSET_FIELD(initParam); -} - -static void -_outScan(StringInfo str, const Scan *node) -{ - WRITE_NODE_TYPE("SCAN"); - - _outScanInfo(str, node); -} - -static void -_outSeqScan(StringInfo str, const SeqScan *node) -{ - WRITE_NODE_TYPE("SEQSCAN"); - - _outScanInfo(str, (const Scan *) node); -} - -static void -_outSampleScan(StringInfo str, const SampleScan *node) -{ - WRITE_NODE_TYPE("SAMPLESCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_NODE_FIELD(tablesample); -} - -static void -_outIndexScan(StringInfo str, const IndexScan *node) -{ - WRITE_NODE_TYPE("INDEXSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_OID_FIELD(indexid); - WRITE_NODE_FIELD(indexqual); - WRITE_NODE_FIELD(indexqualorig); - WRITE_NODE_FIELD(indexorderby); - WRITE_NODE_FIELD(indexorderbyorig); - WRITE_NODE_FIELD(indexorderbyops); - WRITE_ENUM_FIELD(indexorderdir, ScanDirection); -} - -static void -_outIndexOnlyScan(StringInfo str, const IndexOnlyScan *node) -{ - WRITE_NODE_TYPE("INDEXONLYSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_OID_FIELD(indexid); - WRITE_NODE_FIELD(indexqual); - WRITE_NODE_FIELD(recheckqual); - WRITE_NODE_FIELD(indexorderby); - WRITE_NODE_FIELD(indextlist); - WRITE_ENUM_FIELD(indexorderdir, ScanDirection); -} - -static void -_outBitmapIndexScan(StringInfo str, const BitmapIndexScan *node) -{ - WRITE_NODE_TYPE("BITMAPINDEXSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_OID_FIELD(indexid); - WRITE_BOOL_FIELD(isshared); - WRITE_NODE_FIELD(indexqual); - WRITE_NODE_FIELD(indexqualorig); -} - -static void -_outBitmapHeapScan(StringInfo str, const BitmapHeapScan *node) -{ - WRITE_NODE_TYPE("BITMAPHEAPSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_NODE_FIELD(bitmapqualorig); -} - -static void -_outTidScan(StringInfo str, const TidScan *node) -{ - WRITE_NODE_TYPE("TIDSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_NODE_FIELD(tidquals); -} - -static void -_outTidRangeScan(StringInfo str, const TidRangeScan *node) -{ - WRITE_NODE_TYPE("TIDRANGESCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_NODE_FIELD(tidrangequals); -} - -static void -_outSubqueryScan(StringInfo str, const SubqueryScan *node) -{ - WRITE_NODE_TYPE("SUBQUERYSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_NODE_FIELD(subplan); - WRITE_ENUM_FIELD(scanstatus, SubqueryScanStatus); -} - -static void -_outFunctionScan(StringInfo str, const FunctionScan *node) -{ - WRITE_NODE_TYPE("FUNCTIONSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_NODE_FIELD(functions); - WRITE_BOOL_FIELD(funcordinality); -} - -static void -_outTableFuncScan(StringInfo str, const TableFuncScan *node) -{ - WRITE_NODE_TYPE("TABLEFUNCSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_NODE_FIELD(tablefunc); -} - -static void -_outValuesScan(StringInfo str, const ValuesScan *node) -{ - WRITE_NODE_TYPE("VALUESSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_NODE_FIELD(values_lists); -} - -static void -_outCteScan(StringInfo str, const CteScan *node) -{ - WRITE_NODE_TYPE("CTESCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_INT_FIELD(ctePlanId); - WRITE_INT_FIELD(cteParam); -} - -static void -_outNamedTuplestoreScan(StringInfo str, const NamedTuplestoreScan *node) -{ - WRITE_NODE_TYPE("NAMEDTUPLESTORESCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_STRING_FIELD(enrname); -} - -static void -_outWorkTableScan(StringInfo str, const WorkTableScan *node) -{ - WRITE_NODE_TYPE("WORKTABLESCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_INT_FIELD(wtParam); -} - -static void -_outForeignScan(StringInfo str, const ForeignScan *node) -{ - WRITE_NODE_TYPE("FOREIGNSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_ENUM_FIELD(operation, CmdType); - WRITE_UINT_FIELD(resultRelation); - WRITE_OID_FIELD(fs_server); - WRITE_NODE_FIELD(fdw_exprs); - WRITE_NODE_FIELD(fdw_private); - WRITE_NODE_FIELD(fdw_scan_tlist); - WRITE_NODE_FIELD(fdw_recheck_quals); - WRITE_BITMAPSET_FIELD(fs_relids); - WRITE_BOOL_FIELD(fsSystemCol); -} - -static void -_outCustomScan(StringInfo str, const CustomScan *node) -{ - WRITE_NODE_TYPE("CUSTOMSCAN"); - - _outScanInfo(str, (const Scan *) node); - - WRITE_UINT_FIELD(flags); - WRITE_NODE_FIELD(custom_plans); - WRITE_NODE_FIELD(custom_exprs); - WRITE_NODE_FIELD(custom_private); - WRITE_NODE_FIELD(custom_scan_tlist); - WRITE_BITMAPSET_FIELD(custom_relids); - /* CustomName is a key to lookup CustomScanMethods */ - appendStringInfoString(str, " :methods "); - outToken(str, node->methods->CustomName); -} - -static void -_outNestLoop(StringInfo str, const NestLoop *node) -{ - WRITE_NODE_TYPE("NESTLOOP"); - - _outJoinPlanInfo(str, (const Join *) node); - - WRITE_NODE_FIELD(nestParams); -} - -static void -_outMergeJoin(StringInfo str, const MergeJoin *node) -{ - int numCols; - - WRITE_NODE_TYPE("MERGEJOIN"); - - _outJoinPlanInfo(str, (const Join *) node); - - WRITE_BOOL_FIELD(skip_mark_restore); - WRITE_NODE_FIELD(mergeclauses); - - numCols = list_length(node->mergeclauses); - - WRITE_OID_ARRAY(mergeFamilies, numCols); - WRITE_OID_ARRAY(mergeCollations, numCols); - WRITE_INT_ARRAY(mergeStrategies, numCols); - WRITE_BOOL_ARRAY(mergeNullsFirst, numCols); -} - -static void -_outHashJoin(StringInfo str, const HashJoin *node) -{ - WRITE_NODE_TYPE("HASHJOIN"); - - _outJoinPlanInfo(str, (const Join *) node); - - WRITE_NODE_FIELD(hashclauses); - WRITE_NODE_FIELD(hashoperators); - WRITE_NODE_FIELD(hashcollations); - WRITE_NODE_FIELD(hashkeys); -} - -static void -_outAgg(StringInfo str, const Agg *node) -{ - WRITE_NODE_TYPE("AGG"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_ENUM_FIELD(aggstrategy, AggStrategy); - WRITE_ENUM_FIELD(aggsplit, AggSplit); - WRITE_INT_FIELD(numCols); - WRITE_ATTRNUMBER_ARRAY(grpColIdx, node->numCols); - WRITE_OID_ARRAY(grpOperators, node->numCols); - WRITE_OID_ARRAY(grpCollations, node->numCols); - WRITE_LONG_FIELD(numGroups); - WRITE_UINT64_FIELD(transitionSpace); - WRITE_BITMAPSET_FIELD(aggParams); - WRITE_NODE_FIELD(groupingSets); - WRITE_NODE_FIELD(chain); -} - -static void -_outWindowAgg(StringInfo str, const WindowAgg *node) -{ - WRITE_NODE_TYPE("WINDOWAGG"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_UINT_FIELD(winref); - WRITE_INT_FIELD(partNumCols); - WRITE_ATTRNUMBER_ARRAY(partColIdx, node->partNumCols); - WRITE_OID_ARRAY(partOperators, node->partNumCols); - WRITE_OID_ARRAY(partCollations, node->partNumCols); - WRITE_INT_FIELD(ordNumCols); - WRITE_ATTRNUMBER_ARRAY(ordColIdx, node->ordNumCols); - WRITE_OID_ARRAY(ordOperators, node->ordNumCols); - WRITE_OID_ARRAY(ordCollations, node->ordNumCols); - WRITE_INT_FIELD(frameOptions); - WRITE_NODE_FIELD(startOffset); - WRITE_NODE_FIELD(endOffset); - WRITE_NODE_FIELD(runCondition); - WRITE_NODE_FIELD(runConditionOrig); - WRITE_OID_FIELD(startInRangeFunc); - WRITE_OID_FIELD(endInRangeFunc); - WRITE_OID_FIELD(inRangeColl); - WRITE_BOOL_FIELD(inRangeAsc); - WRITE_BOOL_FIELD(inRangeNullsFirst); - WRITE_BOOL_FIELD(topWindow); -} - -static void -_outGroup(StringInfo str, const Group *node) -{ - WRITE_NODE_TYPE("GROUP"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_INT_FIELD(numCols); - WRITE_ATTRNUMBER_ARRAY(grpColIdx, node->numCols); - WRITE_OID_ARRAY(grpOperators, node->numCols); - WRITE_OID_ARRAY(grpCollations, node->numCols); -} - -static void -_outMaterial(StringInfo str, const Material *node) -{ - WRITE_NODE_TYPE("MATERIAL"); - - _outPlanInfo(str, (const Plan *) node); -} - -static void -_outMemoize(StringInfo str, const Memoize *node) -{ - WRITE_NODE_TYPE("MEMOIZE"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_INT_FIELD(numKeys); - WRITE_OID_ARRAY(hashOperators, node->numKeys); - WRITE_OID_ARRAY(collations, node->numKeys); - WRITE_NODE_FIELD(param_exprs); - WRITE_BOOL_FIELD(singlerow); - WRITE_BOOL_FIELD(binary_mode); - WRITE_UINT_FIELD(est_entries); - WRITE_BITMAPSET_FIELD(keyparamids); -} - -static void -_outSortInfo(StringInfo str, const Sort *node) -{ - _outPlanInfo(str, (const Plan *) node); - - WRITE_INT_FIELD(numCols); - WRITE_ATTRNUMBER_ARRAY(sortColIdx, node->numCols); - WRITE_OID_ARRAY(sortOperators, node->numCols); - WRITE_OID_ARRAY(collations, node->numCols); - WRITE_BOOL_ARRAY(nullsFirst, node->numCols); -} - -static void -_outSort(StringInfo str, const Sort *node) -{ - WRITE_NODE_TYPE("SORT"); - - _outSortInfo(str, node); -} - -static void -_outIncrementalSort(StringInfo str, const IncrementalSort *node) -{ - WRITE_NODE_TYPE("INCREMENTALSORT"); - - _outSortInfo(str, (const Sort *) node); - - WRITE_INT_FIELD(nPresortedCols); -} - -static void -_outUnique(StringInfo str, const Unique *node) -{ - WRITE_NODE_TYPE("UNIQUE"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_INT_FIELD(numCols); - WRITE_ATTRNUMBER_ARRAY(uniqColIdx, node->numCols); - WRITE_OID_ARRAY(uniqOperators, node->numCols); - WRITE_OID_ARRAY(uniqCollations, node->numCols); -} - -static void -_outHash(StringInfo str, const Hash *node) -{ - WRITE_NODE_TYPE("HASH"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_NODE_FIELD(hashkeys); - WRITE_OID_FIELD(skewTable); - WRITE_INT_FIELD(skewColumn); - WRITE_BOOL_FIELD(skewInherit); - WRITE_FLOAT_FIELD(rows_total, "%.0f"); -} - -static void -_outSetOp(StringInfo str, const SetOp *node) -{ - WRITE_NODE_TYPE("SETOP"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_ENUM_FIELD(cmd, SetOpCmd); - WRITE_ENUM_FIELD(strategy, SetOpStrategy); - WRITE_INT_FIELD(numCols); - WRITE_ATTRNUMBER_ARRAY(dupColIdx, node->numCols); - WRITE_OID_ARRAY(dupOperators, node->numCols); - WRITE_OID_ARRAY(dupCollations, node->numCols); - WRITE_INT_FIELD(flagColIdx); - WRITE_INT_FIELD(firstFlag); - WRITE_LONG_FIELD(numGroups); -} - -static void -_outLockRows(StringInfo str, const LockRows *node) -{ - WRITE_NODE_TYPE("LOCKROWS"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_NODE_FIELD(rowMarks); - WRITE_INT_FIELD(epqParam); -} - -static void -_outLimit(StringInfo str, const Limit *node) -{ - WRITE_NODE_TYPE("LIMIT"); - - _outPlanInfo(str, (const Plan *) node); - - WRITE_NODE_FIELD(limitOffset); - WRITE_NODE_FIELD(limitCount); - WRITE_ENUM_FIELD(limitOption, LimitOption); - WRITE_INT_FIELD(uniqNumCols); - WRITE_ATTRNUMBER_ARRAY(uniqColIdx, node->uniqNumCols); - WRITE_OID_ARRAY(uniqOperators, node->uniqNumCols); - WRITE_OID_ARRAY(uniqCollations, node->uniqNumCols); -} - -static void -_outNestLoopParam(StringInfo str, const NestLoopParam *node) -{ - WRITE_NODE_TYPE("NESTLOOPPARAM"); - - WRITE_INT_FIELD(paramno); - WRITE_NODE_FIELD(paramval); -} - -static void -_outPlanRowMark(StringInfo str, const PlanRowMark *node) -{ - WRITE_NODE_TYPE("PLANROWMARK"); - - WRITE_UINT_FIELD(rti); - WRITE_UINT_FIELD(prti); - WRITE_UINT_FIELD(rowmarkId); - WRITE_ENUM_FIELD(markType, RowMarkType); - WRITE_INT_FIELD(allMarkTypes); - WRITE_ENUM_FIELD(strength, LockClauseStrength); - WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy); - WRITE_BOOL_FIELD(isParent); -} - -static void -_outPartitionPruneInfo(StringInfo str, const PartitionPruneInfo *node) -{ - WRITE_NODE_TYPE("PARTITIONPRUNEINFO"); - - WRITE_NODE_FIELD(prune_infos); - WRITE_BITMAPSET_FIELD(other_subplans); -} - -static void -_outPartitionedRelPruneInfo(StringInfo str, const PartitionedRelPruneInfo *node) -{ - WRITE_NODE_TYPE("PARTITIONEDRELPRUNEINFO"); - - WRITE_UINT_FIELD(rtindex); - WRITE_BITMAPSET_FIELD(present_parts); - WRITE_INT_FIELD(nparts); - WRITE_INT_ARRAY(subplan_map, node->nparts); - WRITE_INT_ARRAY(subpart_map, node->nparts); - WRITE_OID_ARRAY(relid_map, node->nparts); - WRITE_NODE_FIELD(initial_pruning_steps); - WRITE_NODE_FIELD(exec_pruning_steps); - WRITE_BITMAPSET_FIELD(execparamids); -} - -static void -_outPartitionPruneStepOp(StringInfo str, const PartitionPruneStepOp *node) -{ - WRITE_NODE_TYPE("PARTITIONPRUNESTEPOP"); - - WRITE_INT_FIELD(step.step_id); - WRITE_INT_FIELD(opstrategy); - WRITE_NODE_FIELD(exprs); - WRITE_NODE_FIELD(cmpfns); - WRITE_BITMAPSET_FIELD(nullkeys); -} - -static void -_outPartitionPruneStepCombine(StringInfo str, const PartitionPruneStepCombine *node) -{ - WRITE_NODE_TYPE("PARTITIONPRUNESTEPCOMBINE"); - - WRITE_INT_FIELD(step.step_id); - WRITE_ENUM_FIELD(combineOp, PartitionPruneCombineOp); - WRITE_NODE_FIELD(source_stepids); -} - -static void -_outPlanInvalItem(StringInfo str, const PlanInvalItem *node) -{ - WRITE_NODE_TYPE("PLANINVALITEM"); - - WRITE_INT_FIELD(cacheId); - WRITE_UINT_FIELD(hashValue); -} - -/***************************************************************************** - * - * Stuff from primnodes.h. - * - *****************************************************************************/ - -static void -_outAlias(StringInfo str, const Alias *node) -{ - WRITE_NODE_TYPE("ALIAS"); - - WRITE_STRING_FIELD(aliasname); - WRITE_NODE_FIELD(colnames); -} - -static void -_outRangeVar(StringInfo str, const RangeVar *node) -{ - WRITE_NODE_TYPE("RANGEVAR"); - - /* - * we deliberately ignore catalogname here, since it is presently not - * semantically meaningful - */ - WRITE_STRING_FIELD(schemaname); - WRITE_STRING_FIELD(relname); - WRITE_BOOL_FIELD(inh); - WRITE_CHAR_FIELD(relpersistence); - WRITE_NODE_FIELD(alias); - WRITE_LOCATION_FIELD(location); -} - -static void -_outTableFunc(StringInfo str, const TableFunc *node) -{ - WRITE_NODE_TYPE("TABLEFUNC"); - - WRITE_ENUM_FIELD(functype, TableFuncType); - WRITE_NODE_FIELD(ns_uris); - WRITE_NODE_FIELD(ns_names); - WRITE_NODE_FIELD(docexpr); - WRITE_NODE_FIELD(rowexpr); - WRITE_NODE_FIELD(colnames); - WRITE_NODE_FIELD(coltypes); - WRITE_NODE_FIELD(coltypmods); - WRITE_NODE_FIELD(colcollations); - WRITE_NODE_FIELD(colexprs); - WRITE_NODE_FIELD(coldefexprs); - WRITE_NODE_FIELD(colvalexprs); - WRITE_BITMAPSET_FIELD(notnulls); - WRITE_NODE_FIELD(plan); - WRITE_INT_FIELD(ordinalitycol); - WRITE_LOCATION_FIELD(location); -} - -static void -_outIntoClause(StringInfo str, const IntoClause *node) -{ - WRITE_NODE_TYPE("INTOCLAUSE"); - - WRITE_NODE_FIELD(rel); - WRITE_NODE_FIELD(colNames); - WRITE_STRING_FIELD(accessMethod); - WRITE_NODE_FIELD(options); - WRITE_ENUM_FIELD(onCommit, OnCommitAction); - WRITE_STRING_FIELD(tableSpaceName); - WRITE_NODE_FIELD(viewQuery); - WRITE_BOOL_FIELD(skipData); -} - -static void -_outVar(StringInfo str, const Var *node) -{ - WRITE_NODE_TYPE("VAR"); - - WRITE_INT_FIELD(varno); - WRITE_INT_FIELD(varattno); - WRITE_OID_FIELD(vartype); - WRITE_INT_FIELD(vartypmod); - WRITE_OID_FIELD(varcollid); - WRITE_UINT_FIELD(varlevelsup); - WRITE_UINT_FIELD(varnosyn); - WRITE_INT_FIELD(varattnosyn); - WRITE_LOCATION_FIELD(location); -} -#endif /* OBSOLETE */ static void _outConst(StringInfo str, const Const *node) @@ -1162,179 +333,6 @@ _outConst(StringInfo str, const Const *node) outDatum(str, node->constvalue, node->constlen, node->constbyval); } -#ifdef OBSOLETE -static void -_outParam(StringInfo str, const Param *node) -{ - WRITE_NODE_TYPE("PARAM"); - - WRITE_ENUM_FIELD(paramkind, ParamKind); - WRITE_INT_FIELD(paramid); - WRITE_OID_FIELD(paramtype); - WRITE_INT_FIELD(paramtypmod); - WRITE_OID_FIELD(paramcollid); - WRITE_LOCATION_FIELD(location); -} - -static void -_outAggref(StringInfo str, const Aggref *node) -{ - WRITE_NODE_TYPE("AGGREF"); - - WRITE_OID_FIELD(aggfnoid); - WRITE_OID_FIELD(aggtype); - WRITE_OID_FIELD(aggcollid); - WRITE_OID_FIELD(inputcollid); - WRITE_OID_FIELD(aggtranstype); - WRITE_NODE_FIELD(aggargtypes); - WRITE_NODE_FIELD(aggdirectargs); - WRITE_NODE_FIELD(args); - WRITE_NODE_FIELD(aggorder); - WRITE_NODE_FIELD(aggdistinct); - WRITE_NODE_FIELD(aggfilter); - WRITE_BOOL_FIELD(aggstar); - WRITE_BOOL_FIELD(aggvariadic); - WRITE_CHAR_FIELD(aggkind); - WRITE_UINT_FIELD(agglevelsup); - WRITE_ENUM_FIELD(aggsplit, AggSplit); - WRITE_INT_FIELD(aggno); - WRITE_INT_FIELD(aggtransno); - WRITE_LOCATION_FIELD(location); -} - -static void -_outGroupingFunc(StringInfo str, const GroupingFunc *node) -{ - WRITE_NODE_TYPE("GROUPINGFUNC"); - - WRITE_NODE_FIELD(args); - WRITE_NODE_FIELD(refs); - WRITE_NODE_FIELD(cols); - WRITE_UINT_FIELD(agglevelsup); - WRITE_LOCATION_FIELD(location); -} - -static void -_outWindowFunc(StringInfo str, const WindowFunc *node) -{ - WRITE_NODE_TYPE("WINDOWFUNC"); - - WRITE_OID_FIELD(winfnoid); - WRITE_OID_FIELD(wintype); - WRITE_OID_FIELD(wincollid); - WRITE_OID_FIELD(inputcollid); - WRITE_NODE_FIELD(args); - WRITE_NODE_FIELD(aggfilter); - WRITE_UINT_FIELD(winref); - WRITE_BOOL_FIELD(winstar); - WRITE_BOOL_FIELD(winagg); - WRITE_LOCATION_FIELD(location); -} - -static void -_outSubscriptingRef(StringInfo str, const SubscriptingRef *node) -{ - WRITE_NODE_TYPE("SUBSCRIPTINGREF"); - - WRITE_OID_FIELD(refcontainertype); - WRITE_OID_FIELD(refelemtype); - WRITE_OID_FIELD(refrestype); - WRITE_INT_FIELD(reftypmod); - WRITE_OID_FIELD(refcollid); - WRITE_NODE_FIELD(refupperindexpr); - WRITE_NODE_FIELD(reflowerindexpr); - WRITE_NODE_FIELD(refexpr); - WRITE_NODE_FIELD(refassgnexpr); -} - -static void -_outFuncExpr(StringInfo str, const FuncExpr *node) -{ - WRITE_NODE_TYPE("FUNCEXPR"); - - WRITE_OID_FIELD(funcid); - WRITE_OID_FIELD(funcresulttype); - WRITE_BOOL_FIELD(funcretset); - WRITE_BOOL_FIELD(funcvariadic); - WRITE_ENUM_FIELD(funcformat, CoercionForm); - WRITE_OID_FIELD(funccollid); - WRITE_OID_FIELD(inputcollid); - WRITE_NODE_FIELD(args); - WRITE_LOCATION_FIELD(location); -} - -static void -_outNamedArgExpr(StringInfo str, const NamedArgExpr *node) -{ - WRITE_NODE_TYPE("NAMEDARGEXPR"); - - WRITE_NODE_FIELD(arg); - WRITE_STRING_FIELD(name); - WRITE_INT_FIELD(argnumber); - WRITE_LOCATION_FIELD(location); -} - -static void -_outOpExpr(StringInfo str, const OpExpr *node) -{ - WRITE_NODE_TYPE("OPEXPR"); - - WRITE_OID_FIELD(opno); - WRITE_OID_FIELD(opfuncid); - WRITE_OID_FIELD(opresulttype); - WRITE_BOOL_FIELD(opretset); - WRITE_OID_FIELD(opcollid); - WRITE_OID_FIELD(inputcollid); - WRITE_NODE_FIELD(args); - WRITE_LOCATION_FIELD(location); -} - -static void -_outDistinctExpr(StringInfo str, const DistinctExpr *node) -{ - WRITE_NODE_TYPE("DISTINCTEXPR"); - - WRITE_OID_FIELD(opno); - WRITE_OID_FIELD(opfuncid); - WRITE_OID_FIELD(opresulttype); - WRITE_BOOL_FIELD(opretset); - WRITE_OID_FIELD(opcollid); - WRITE_OID_FIELD(inputcollid); - WRITE_NODE_FIELD(args); - WRITE_LOCATION_FIELD(location); -} - -static void -_outNullIfExpr(StringInfo str, const NullIfExpr *node) -{ - WRITE_NODE_TYPE("NULLIFEXPR"); - - WRITE_OID_FIELD(opno); - WRITE_OID_FIELD(opfuncid); - WRITE_OID_FIELD(opresulttype); - WRITE_BOOL_FIELD(opretset); - WRITE_OID_FIELD(opcollid); - WRITE_OID_FIELD(inputcollid); - WRITE_NODE_FIELD(args); - WRITE_LOCATION_FIELD(location); -} - -static void -_outScalarArrayOpExpr(StringInfo str, const ScalarArrayOpExpr *node) -{ - WRITE_NODE_TYPE("SCALARARRAYOPEXPR"); - - WRITE_OID_FIELD(opno); - WRITE_OID_FIELD(opfuncid); - WRITE_OID_FIELD(hashfuncid); - WRITE_OID_FIELD(negfuncid); - WRITE_BOOL_FIELD(useOr); - WRITE_OID_FIELD(inputcollid); - WRITE_NODE_FIELD(args); - WRITE_LOCATION_FIELD(location); -} -#endif /* OBSOLETE */ - static void _outBoolExpr(StringInfo str, const BoolExpr *node) { @@ -1362,1221 +360,6 @@ _outBoolExpr(StringInfo str, const BoolExpr *node) WRITE_LOCATION_FIELD(location); } -#ifdef OBSOLETE -static void -_outSubLink(StringInfo str, const SubLink *node) -{ - WRITE_NODE_TYPE("SUBLINK"); - - WRITE_ENUM_FIELD(subLinkType, SubLinkType); - WRITE_INT_FIELD(subLinkId); - WRITE_NODE_FIELD(testexpr); - WRITE_NODE_FIELD(operName); - WRITE_NODE_FIELD(subselect); - WRITE_LOCATION_FIELD(location); -} - -static void -_outSubPlan(StringInfo str, const SubPlan *node) -{ - WRITE_NODE_TYPE("SUBPLAN"); - - WRITE_ENUM_FIELD(subLinkType, SubLinkType); - WRITE_NODE_FIELD(testexpr); - WRITE_NODE_FIELD(paramIds); - WRITE_INT_FIELD(plan_id); - WRITE_STRING_FIELD(plan_name); - WRITE_OID_FIELD(firstColType); - WRITE_INT_FIELD(firstColTypmod); - WRITE_OID_FIELD(firstColCollation); - WRITE_BOOL_FIELD(useHashTable); - WRITE_BOOL_FIELD(unknownEqFalse); - WRITE_BOOL_FIELD(parallel_safe); - WRITE_NODE_FIELD(setParam); - WRITE_NODE_FIELD(parParam); - WRITE_NODE_FIELD(args); - WRITE_FLOAT_FIELD(startup_cost, "%.2f"); - WRITE_FLOAT_FIELD(per_call_cost, "%.2f"); -} - -static void -_outAlternativeSubPlan(StringInfo str, const AlternativeSubPlan *node) -{ - WRITE_NODE_TYPE("ALTERNATIVESUBPLAN"); - - WRITE_NODE_FIELD(subplans); -} - -static void -_outFieldSelect(StringInfo str, const FieldSelect *node) -{ - WRITE_NODE_TYPE("FIELDSELECT"); - - WRITE_NODE_FIELD(arg); - WRITE_INT_FIELD(fieldnum); - WRITE_OID_FIELD(resulttype); - WRITE_INT_FIELD(resulttypmod); - WRITE_OID_FIELD(resultcollid); -} - -static void -_outFieldStore(StringInfo str, const FieldStore *node) -{ - WRITE_NODE_TYPE("FIELDSTORE"); - - WRITE_NODE_FIELD(arg); - WRITE_NODE_FIELD(newvals); - WRITE_NODE_FIELD(fieldnums); - WRITE_OID_FIELD(resulttype); -} - -static void -_outRelabelType(StringInfo str, const RelabelType *node) -{ - WRITE_NODE_TYPE("RELABELTYPE"); - - WRITE_NODE_FIELD(arg); - WRITE_OID_FIELD(resulttype); - WRITE_INT_FIELD(resulttypmod); - WRITE_OID_FIELD(resultcollid); - WRITE_ENUM_FIELD(relabelformat, CoercionForm); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCoerceViaIO(StringInfo str, const CoerceViaIO *node) -{ - WRITE_NODE_TYPE("COERCEVIAIO"); - - WRITE_NODE_FIELD(arg); - WRITE_OID_FIELD(resulttype); - WRITE_OID_FIELD(resultcollid); - WRITE_ENUM_FIELD(coerceformat, CoercionForm); - WRITE_LOCATION_FIELD(location); -} - -static void -_outArrayCoerceExpr(StringInfo str, const ArrayCoerceExpr *node) -{ - WRITE_NODE_TYPE("ARRAYCOERCEEXPR"); - - WRITE_NODE_FIELD(arg); - WRITE_NODE_FIELD(elemexpr); - WRITE_OID_FIELD(resulttype); - WRITE_INT_FIELD(resulttypmod); - WRITE_OID_FIELD(resultcollid); - WRITE_ENUM_FIELD(coerceformat, CoercionForm); - WRITE_LOCATION_FIELD(location); -} - -static void -_outConvertRowtypeExpr(StringInfo str, const ConvertRowtypeExpr *node) -{ - WRITE_NODE_TYPE("CONVERTROWTYPEEXPR"); - - WRITE_NODE_FIELD(arg); - WRITE_OID_FIELD(resulttype); - WRITE_ENUM_FIELD(convertformat, CoercionForm); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCollateExpr(StringInfo str, const CollateExpr *node) -{ - WRITE_NODE_TYPE("COLLATEEXPR"); - - WRITE_NODE_FIELD(arg); - WRITE_OID_FIELD(collOid); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCaseExpr(StringInfo str, const CaseExpr *node) -{ - WRITE_NODE_TYPE("CASEEXPR"); - - WRITE_OID_FIELD(casetype); - WRITE_OID_FIELD(casecollid); - WRITE_NODE_FIELD(arg); - WRITE_NODE_FIELD(args); - WRITE_NODE_FIELD(defresult); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCaseWhen(StringInfo str, const CaseWhen *node) -{ - WRITE_NODE_TYPE("CASEWHEN"); - - WRITE_NODE_FIELD(expr); - WRITE_NODE_FIELD(result); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCaseTestExpr(StringInfo str, const CaseTestExpr *node) -{ - WRITE_NODE_TYPE("CASETESTEXPR"); - - WRITE_OID_FIELD(typeId); - WRITE_INT_FIELD(typeMod); - WRITE_OID_FIELD(collation); -} - -static void -_outArrayExpr(StringInfo str, const ArrayExpr *node) -{ - WRITE_NODE_TYPE("ARRAYEXPR"); - - WRITE_OID_FIELD(array_typeid); - WRITE_OID_FIELD(array_collid); - WRITE_OID_FIELD(element_typeid); - WRITE_NODE_FIELD(elements); - WRITE_BOOL_FIELD(multidims); - WRITE_LOCATION_FIELD(location); -} - -static void -_outRowExpr(StringInfo str, const RowExpr *node) -{ - WRITE_NODE_TYPE("ROWEXPR"); - - WRITE_NODE_FIELD(args); - WRITE_OID_FIELD(row_typeid); - WRITE_ENUM_FIELD(row_format, CoercionForm); - WRITE_NODE_FIELD(colnames); - WRITE_LOCATION_FIELD(location); -} - -static void -_outRowCompareExpr(StringInfo str, const RowCompareExpr *node) -{ - WRITE_NODE_TYPE("ROWCOMPAREEXPR"); - - WRITE_ENUM_FIELD(rctype, RowCompareType); - WRITE_NODE_FIELD(opnos); - WRITE_NODE_FIELD(opfamilies); - WRITE_NODE_FIELD(inputcollids); - WRITE_NODE_FIELD(largs); - WRITE_NODE_FIELD(rargs); -} - -static void -_outCoalesceExpr(StringInfo str, const CoalesceExpr *node) -{ - WRITE_NODE_TYPE("COALESCEEXPR"); - - WRITE_OID_FIELD(coalescetype); - WRITE_OID_FIELD(coalescecollid); - WRITE_NODE_FIELD(args); - WRITE_LOCATION_FIELD(location); -} - -static void -_outMinMaxExpr(StringInfo str, const MinMaxExpr *node) -{ - WRITE_NODE_TYPE("MINMAXEXPR"); - - WRITE_OID_FIELD(minmaxtype); - WRITE_OID_FIELD(minmaxcollid); - WRITE_OID_FIELD(inputcollid); - WRITE_ENUM_FIELD(op, MinMaxOp); - WRITE_NODE_FIELD(args); - WRITE_LOCATION_FIELD(location); -} - -static void -_outSQLValueFunction(StringInfo str, const SQLValueFunction *node) -{ - WRITE_NODE_TYPE("SQLVALUEFUNCTION"); - - WRITE_ENUM_FIELD(op, SQLValueFunctionOp); - WRITE_OID_FIELD(type); - WRITE_INT_FIELD(typmod); - WRITE_LOCATION_FIELD(location); -} - -static void -_outXmlExpr(StringInfo str, const XmlExpr *node) -{ - WRITE_NODE_TYPE("XMLEXPR"); - - WRITE_ENUM_FIELD(op, XmlExprOp); - WRITE_STRING_FIELD(name); - WRITE_NODE_FIELD(named_args); - WRITE_NODE_FIELD(arg_names); - WRITE_NODE_FIELD(args); - WRITE_ENUM_FIELD(xmloption, XmlOptionType); - WRITE_OID_FIELD(type); - WRITE_INT_FIELD(typmod); - WRITE_LOCATION_FIELD(location); -} - -static void -_outNullTest(StringInfo str, const NullTest *node) -{ - WRITE_NODE_TYPE("NULLTEST"); - - WRITE_NODE_FIELD(arg); - WRITE_ENUM_FIELD(nulltesttype, NullTestType); - WRITE_BOOL_FIELD(argisrow); - WRITE_LOCATION_FIELD(location); -} - -static void -_outBooleanTest(StringInfo str, const BooleanTest *node) -{ - WRITE_NODE_TYPE("BOOLEANTEST"); - - WRITE_NODE_FIELD(arg); - WRITE_ENUM_FIELD(booltesttype, BoolTestType); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCoerceToDomain(StringInfo str, const CoerceToDomain *node) -{ - WRITE_NODE_TYPE("COERCETODOMAIN"); - - WRITE_NODE_FIELD(arg); - WRITE_OID_FIELD(resulttype); - WRITE_INT_FIELD(resulttypmod); - WRITE_OID_FIELD(resultcollid); - WRITE_ENUM_FIELD(coercionformat, CoercionForm); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCoerceToDomainValue(StringInfo str, const CoerceToDomainValue *node) -{ - WRITE_NODE_TYPE("COERCETODOMAINVALUE"); - - WRITE_OID_FIELD(typeId); - WRITE_INT_FIELD(typeMod); - WRITE_OID_FIELD(collation); - WRITE_LOCATION_FIELD(location); -} - -static void -_outSetToDefault(StringInfo str, const SetToDefault *node) -{ - WRITE_NODE_TYPE("SETTODEFAULT"); - - WRITE_OID_FIELD(typeId); - WRITE_INT_FIELD(typeMod); - WRITE_OID_FIELD(collation); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCurrentOfExpr(StringInfo str, const CurrentOfExpr *node) -{ - WRITE_NODE_TYPE("CURRENTOFEXPR"); - - WRITE_UINT_FIELD(cvarno); - WRITE_STRING_FIELD(cursor_name); - WRITE_INT_FIELD(cursor_param); -} - -static void -_outNextValueExpr(StringInfo str, const NextValueExpr *node) -{ - WRITE_NODE_TYPE("NEXTVALUEEXPR"); - - WRITE_OID_FIELD(seqid); - WRITE_OID_FIELD(typeId); -} - -static void -_outInferenceElem(StringInfo str, const InferenceElem *node) -{ - WRITE_NODE_TYPE("INFERENCEELEM"); - - WRITE_NODE_FIELD(expr); - WRITE_OID_FIELD(infercollid); - WRITE_OID_FIELD(inferopclass); -} - -static void -_outTargetEntry(StringInfo str, const TargetEntry *node) -{ - WRITE_NODE_TYPE("TARGETENTRY"); - - WRITE_NODE_FIELD(expr); - WRITE_INT_FIELD(resno); - WRITE_STRING_FIELD(resname); - WRITE_UINT_FIELD(ressortgroupref); - WRITE_OID_FIELD(resorigtbl); - WRITE_INT_FIELD(resorigcol); - WRITE_BOOL_FIELD(resjunk); -} - -static void -_outRangeTblRef(StringInfo str, const RangeTblRef *node) -{ - WRITE_NODE_TYPE("RANGETBLREF"); - - WRITE_INT_FIELD(rtindex); -} - -static void -_outJoinExpr(StringInfo str, const JoinExpr *node) -{ - WRITE_NODE_TYPE("JOINEXPR"); - - WRITE_ENUM_FIELD(jointype, JoinType); - WRITE_BOOL_FIELD(isNatural); - WRITE_NODE_FIELD(larg); - WRITE_NODE_FIELD(rarg); - WRITE_NODE_FIELD(usingClause); - WRITE_NODE_FIELD(join_using_alias); - WRITE_NODE_FIELD(quals); - WRITE_NODE_FIELD(alias); - WRITE_INT_FIELD(rtindex); -} - -static void -_outFromExpr(StringInfo str, const FromExpr *node) -{ - WRITE_NODE_TYPE("FROMEXPR"); - - WRITE_NODE_FIELD(fromlist); - WRITE_NODE_FIELD(quals); -} - -static void -_outOnConflictExpr(StringInfo str, const OnConflictExpr *node) -{ - WRITE_NODE_TYPE("ONCONFLICTEXPR"); - - WRITE_ENUM_FIELD(action, OnConflictAction); - WRITE_NODE_FIELD(arbiterElems); - WRITE_NODE_FIELD(arbiterWhere); - WRITE_OID_FIELD(constraint); - WRITE_NODE_FIELD(onConflictSet); - WRITE_NODE_FIELD(onConflictWhere); - WRITE_INT_FIELD(exclRelIndex); - WRITE_NODE_FIELD(exclRelTlist); -} - -static void -_outJsonFormat(StringInfo str, const JsonFormat *node) -{ - WRITE_NODE_TYPE("JSONFORMAT"); - - WRITE_ENUM_FIELD(format_type, JsonFormatType); - WRITE_ENUM_FIELD(encoding, JsonEncoding); - WRITE_LOCATION_FIELD(location); -} - -static void -_outJsonReturning(StringInfo str, const JsonReturning *node) -{ - WRITE_NODE_TYPE("JSONRETURNING"); - - WRITE_NODE_FIELD(format); - WRITE_OID_FIELD(typid); - WRITE_INT_FIELD(typmod); -} - -static void -_outJsonValueExpr(StringInfo str, const JsonValueExpr *node) -{ - WRITE_NODE_TYPE("JSONVALUEEXPR"); - - WRITE_NODE_FIELD(raw_expr); - WRITE_NODE_FIELD(formatted_expr); - WRITE_NODE_FIELD(format); -} - -static void -_outJsonConstructorExpr(StringInfo str, const JsonConstructorExpr *node) -{ - WRITE_NODE_TYPE("JSONCONSTRUCTOREXPR"); - - WRITE_ENUM_FIELD(type, JsonConstructorType); - WRITE_NODE_FIELD(args); - WRITE_NODE_FIELD(func); - WRITE_NODE_FIELD(coercion); - WRITE_NODE_FIELD(returning); - WRITE_BOOL_FIELD(absent_on_null); - WRITE_BOOL_FIELD(unique); - WRITE_LOCATION_FIELD(location); -} - -static void -_outJsonIsPredicate(StringInfo str, const JsonIsPredicate *node) -{ - WRITE_NODE_TYPE("JSONISPREDICATE"); - - WRITE_NODE_FIELD(expr); - WRITE_NODE_FIELD(format); - WRITE_ENUM_FIELD(item_type, JsonValueType); - WRITE_BOOL_FIELD(unique_keys); - WRITE_LOCATION_FIELD(location); -} - -static void -_outJsonBehavior(StringInfo str, const JsonBehavior *node) -{ - WRITE_NODE_TYPE("JSONBEHAVIOR"); - - WRITE_ENUM_FIELD(btype, JsonBehaviorType); - WRITE_NODE_FIELD(default_expr); -} - -static void -_outJsonExpr(StringInfo str, const JsonExpr *node) -{ - WRITE_NODE_TYPE("JSONEXPR"); - - WRITE_ENUM_FIELD(op, JsonExprOp); - WRITE_NODE_FIELD(formatted_expr); - WRITE_NODE_FIELD(result_coercion); - WRITE_NODE_FIELD(format); - WRITE_NODE_FIELD(path_spec); - WRITE_NODE_FIELD(passing_names); - WRITE_NODE_FIELD(passing_values); - WRITE_NODE_FIELD(returning); - WRITE_NODE_FIELD(on_empty); - WRITE_NODE_FIELD(on_error); - WRITE_NODE_FIELD(coercions); - WRITE_ENUM_FIELD(wrapper, JsonWrapper); - WRITE_BOOL_FIELD(omit_quotes); - WRITE_LOCATION_FIELD(location); -} - -static void -_outJsonCoercion(StringInfo str, const JsonCoercion *node) -{ - WRITE_NODE_TYPE("JSONCOERCION"); - - WRITE_NODE_FIELD(expr); - WRITE_BOOL_FIELD(via_populate); - WRITE_BOOL_FIELD(via_io); - WRITE_OID_FIELD(collation); -} - -static void -_outJsonItemCoercions(StringInfo str, const JsonItemCoercions *node) -{ - WRITE_NODE_TYPE("JSONITEMCOERCIONS"); - - WRITE_NODE_FIELD(null); - WRITE_NODE_FIELD(string); - WRITE_NODE_FIELD(numeric); - WRITE_NODE_FIELD(boolean); - WRITE_NODE_FIELD(date); - WRITE_NODE_FIELD(time); - WRITE_NODE_FIELD(timetz); - WRITE_NODE_FIELD(timestamp); - WRITE_NODE_FIELD(timestamptz); - WRITE_NODE_FIELD(composite); -} - -static void -_outJsonTableParent(StringInfo str, const JsonTableParent *node) -{ - WRITE_NODE_TYPE("JSONTABLEPARENT"); - - WRITE_NODE_FIELD(path); - WRITE_STRING_FIELD(name); - WRITE_NODE_FIELD(child); - WRITE_BOOL_FIELD(outerJoin); - WRITE_INT_FIELD(colMin); - WRITE_INT_FIELD(colMax); - WRITE_BOOL_FIELD(errorOnError); -} - -static void -_outJsonTableSibling(StringInfo str, const JsonTableSibling *node) -{ - WRITE_NODE_TYPE("JSONTABLESIBLING"); - - WRITE_NODE_FIELD(larg); - WRITE_NODE_FIELD(rarg); - WRITE_BOOL_FIELD(cross); -} - -/***************************************************************************** - * - * Stuff from pathnodes.h. - * - *****************************************************************************/ - -/* - * print the basic stuff of all nodes that inherit from Path - * - * Note we do NOT print the parent, else we'd be in infinite recursion. - * We can print the parent's relids for identification purposes, though. - * We print the pathtarget only if it's not the default one for the rel. - * We also do not print the whole of param_info, since it's printed by - * _outRelOptInfo; it's sufficient and less cluttering to print just the - * required outer relids. - */ -static void -_outPathInfo(StringInfo str, const Path *node) -{ - WRITE_ENUM_FIELD(pathtype, NodeTag); - appendStringInfoString(str, " :parent_relids "); - outBitmapset(str, node->parent->relids); - if (node->pathtarget != node->parent->reltarget) - WRITE_NODE_FIELD(pathtarget); - appendStringInfoString(str, " :required_outer "); - if (node->param_info) - outBitmapset(str, node->param_info->ppi_req_outer); - else - outBitmapset(str, NULL); - WRITE_BOOL_FIELD(parallel_aware); - WRITE_BOOL_FIELD(parallel_safe); - WRITE_INT_FIELD(parallel_workers); - WRITE_FLOAT_FIELD(rows, "%.0f"); - WRITE_FLOAT_FIELD(startup_cost, "%.2f"); - WRITE_FLOAT_FIELD(total_cost, "%.2f"); - WRITE_NODE_FIELD(pathkeys); -} - -/* - * print the basic stuff of all nodes that inherit from JoinPath - */ -static void -_outJoinPathInfo(StringInfo str, const JoinPath *node) -{ - _outPathInfo(str, (const Path *) node); - - WRITE_ENUM_FIELD(jointype, JoinType); - WRITE_BOOL_FIELD(inner_unique); - WRITE_NODE_FIELD(outerjoinpath); - WRITE_NODE_FIELD(innerjoinpath); - WRITE_NODE_FIELD(joinrestrictinfo); -} - -static void -_outPath(StringInfo str, const Path *node) -{ - WRITE_NODE_TYPE("PATH"); - - _outPathInfo(str, (const Path *) node); -} - -static void -_outIndexPath(StringInfo str, const IndexPath *node) -{ - WRITE_NODE_TYPE("INDEXPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(indexinfo); - WRITE_NODE_FIELD(indexclauses); - WRITE_NODE_FIELD(indexorderbys); - WRITE_NODE_FIELD(indexorderbycols); - WRITE_ENUM_FIELD(indexscandir, ScanDirection); - WRITE_FLOAT_FIELD(indextotalcost, "%.2f"); - WRITE_FLOAT_FIELD(indexselectivity, "%.4f"); -} - -static void -_outBitmapHeapPath(StringInfo str, const BitmapHeapPath *node) -{ - WRITE_NODE_TYPE("BITMAPHEAPPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(bitmapqual); -} - -static void -_outBitmapAndPath(StringInfo str, const BitmapAndPath *node) -{ - WRITE_NODE_TYPE("BITMAPANDPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(bitmapquals); - WRITE_FLOAT_FIELD(bitmapselectivity, "%.4f"); -} - -static void -_outBitmapOrPath(StringInfo str, const BitmapOrPath *node) -{ - WRITE_NODE_TYPE("BITMAPORPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(bitmapquals); - WRITE_FLOAT_FIELD(bitmapselectivity, "%.4f"); -} - -static void -_outTidPath(StringInfo str, const TidPath *node) -{ - WRITE_NODE_TYPE("TIDPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(tidquals); -} - -static void -_outTidRangePath(StringInfo str, const TidRangePath *node) -{ - WRITE_NODE_TYPE("TIDRANGEPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(tidrangequals); -} - -static void -_outSubqueryScanPath(StringInfo str, const SubqueryScanPath *node) -{ - WRITE_NODE_TYPE("SUBQUERYSCANPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); -} - -static void -_outForeignPath(StringInfo str, const ForeignPath *node) -{ - WRITE_NODE_TYPE("FOREIGNPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(fdw_outerpath); - WRITE_NODE_FIELD(fdw_private); -} - -static void -_outCustomPath(StringInfo str, const CustomPath *node) -{ - WRITE_NODE_TYPE("CUSTOMPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_UINT_FIELD(flags); - WRITE_NODE_FIELD(custom_paths); - WRITE_NODE_FIELD(custom_private); - appendStringInfoString(str, " :methods "); - outToken(str, node->methods->CustomName); -} - -static void -_outAppendPath(StringInfo str, const AppendPath *node) -{ - WRITE_NODE_TYPE("APPENDPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpaths); - WRITE_INT_FIELD(first_partial_path); - WRITE_FLOAT_FIELD(limit_tuples, "%.0f"); -} - -static void -_outMergeAppendPath(StringInfo str, const MergeAppendPath *node) -{ - WRITE_NODE_TYPE("MERGEAPPENDPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpaths); - WRITE_FLOAT_FIELD(limit_tuples, "%.0f"); -} - -static void -_outGroupResultPath(StringInfo str, const GroupResultPath *node) -{ - WRITE_NODE_TYPE("GROUPRESULTPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(quals); -} - -static void -_outMaterialPath(StringInfo str, const MaterialPath *node) -{ - WRITE_NODE_TYPE("MATERIALPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); -} - -static void -_outMemoizePath(StringInfo str, const MemoizePath *node) -{ - WRITE_NODE_TYPE("MEMOIZEPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_NODE_FIELD(hash_operators); - WRITE_NODE_FIELD(param_exprs); - WRITE_BOOL_FIELD(singlerow); - WRITE_BOOL_FIELD(binary_mode); - WRITE_FLOAT_FIELD(calls, "%.0f"); - WRITE_UINT_FIELD(est_entries); -} - -static void -_outUniquePath(StringInfo str, const UniquePath *node) -{ - WRITE_NODE_TYPE("UNIQUEPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_ENUM_FIELD(umethod, UniquePathMethod); - WRITE_NODE_FIELD(in_operators); - WRITE_NODE_FIELD(uniq_exprs); -} - -static void -_outGatherPath(StringInfo str, const GatherPath *node) -{ - WRITE_NODE_TYPE("GATHERPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_BOOL_FIELD(single_copy); - WRITE_INT_FIELD(num_workers); -} - -static void -_outProjectionPath(StringInfo str, const ProjectionPath *node) -{ - WRITE_NODE_TYPE("PROJECTIONPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_BOOL_FIELD(dummypp); -} - -static void -_outProjectSetPath(StringInfo str, const ProjectSetPath *node) -{ - WRITE_NODE_TYPE("PROJECTSETPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); -} - -static void -_outSortPathInfo(StringInfo str, const SortPath *node) -{ - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); -} - -static void -_outSortPath(StringInfo str, const SortPath *node) -{ - WRITE_NODE_TYPE("SORTPATH"); - - _outSortPathInfo(str, node); -} - -static void -_outIncrementalSortPath(StringInfo str, const IncrementalSortPath *node) -{ - WRITE_NODE_TYPE("INCREMENTALSORTPATH"); - - _outSortPathInfo(str, (const SortPath *) node); - - WRITE_INT_FIELD(nPresortedCols); -} - -static void -_outGroupPath(StringInfo str, const GroupPath *node) -{ - WRITE_NODE_TYPE("GROUPPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_NODE_FIELD(groupClause); - WRITE_NODE_FIELD(qual); -} - -static void -_outUpperUniquePath(StringInfo str, const UpperUniquePath *node) -{ - WRITE_NODE_TYPE("UPPERUNIQUEPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_INT_FIELD(numkeys); -} - -static void -_outAggPath(StringInfo str, const AggPath *node) -{ - WRITE_NODE_TYPE("AGGPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_ENUM_FIELD(aggstrategy, AggStrategy); - WRITE_ENUM_FIELD(aggsplit, AggSplit); - WRITE_FLOAT_FIELD(numGroups, "%.0f"); - WRITE_UINT64_FIELD(transitionSpace); - WRITE_NODE_FIELD(groupClause); - WRITE_NODE_FIELD(qual); -} - -static void -_outRollupData(StringInfo str, const RollupData *node) -{ - WRITE_NODE_TYPE("ROLLUP"); - - WRITE_NODE_FIELD(groupClause); - WRITE_NODE_FIELD(gsets); - WRITE_NODE_FIELD(gsets_data); - WRITE_FLOAT_FIELD(numGroups, "%.0f"); - WRITE_BOOL_FIELD(hashable); - WRITE_BOOL_FIELD(is_hashed); -} - -static void -_outGroupingSetData(StringInfo str, const GroupingSetData *node) -{ - WRITE_NODE_TYPE("GSDATA"); - - WRITE_NODE_FIELD(set); - WRITE_FLOAT_FIELD(numGroups, "%.0f"); -} - -static void -_outGroupingSetsPath(StringInfo str, const GroupingSetsPath *node) -{ - WRITE_NODE_TYPE("GROUPINGSETSPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_ENUM_FIELD(aggstrategy, AggStrategy); - WRITE_NODE_FIELD(rollups); - WRITE_NODE_FIELD(qual); - WRITE_UINT64_FIELD(transitionSpace); -} - -static void -_outMinMaxAggPath(StringInfo str, const MinMaxAggPath *node) -{ - WRITE_NODE_TYPE("MINMAXAGGPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(mmaggregates); - WRITE_NODE_FIELD(quals); -} - -static void -_outWindowAggPath(StringInfo str, const WindowAggPath *node) -{ - WRITE_NODE_TYPE("WINDOWAGGPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_NODE_FIELD(winclause); - WRITE_NODE_FIELD(qual); - WRITE_BOOL_FIELD(topwindow); -} - -static void -_outSetOpPath(StringInfo str, const SetOpPath *node) -{ - WRITE_NODE_TYPE("SETOPPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_ENUM_FIELD(cmd, SetOpCmd); - WRITE_ENUM_FIELD(strategy, SetOpStrategy); - WRITE_NODE_FIELD(distinctList); - WRITE_INT_FIELD(flagColIdx); - WRITE_INT_FIELD(firstFlag); - WRITE_FLOAT_FIELD(numGroups, "%.0f"); -} - -static void -_outRecursiveUnionPath(StringInfo str, const RecursiveUnionPath *node) -{ - WRITE_NODE_TYPE("RECURSIVEUNIONPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(leftpath); - WRITE_NODE_FIELD(rightpath); - WRITE_NODE_FIELD(distinctList); - WRITE_INT_FIELD(wtParam); - WRITE_FLOAT_FIELD(numGroups, "%.0f"); -} - -static void -_outLockRowsPath(StringInfo str, const LockRowsPath *node) -{ - WRITE_NODE_TYPE("LOCKROWSPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_NODE_FIELD(rowMarks); - WRITE_INT_FIELD(epqParam); -} - -static void -_outModifyTablePath(StringInfo str, const ModifyTablePath *node) -{ - WRITE_NODE_TYPE("MODIFYTABLEPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_ENUM_FIELD(operation, CmdType); - WRITE_BOOL_FIELD(canSetTag); - WRITE_UINT_FIELD(nominalRelation); - WRITE_UINT_FIELD(rootRelation); - WRITE_BOOL_FIELD(partColsUpdated); - WRITE_NODE_FIELD(resultRelations); - WRITE_NODE_FIELD(updateColnosLists); - WRITE_NODE_FIELD(withCheckOptionLists); - WRITE_NODE_FIELD(returningLists); - WRITE_NODE_FIELD(rowMarks); - WRITE_NODE_FIELD(onconflict); - WRITE_INT_FIELD(epqParam); - WRITE_NODE_FIELD(mergeActionLists); -} - -static void -_outLimitPath(StringInfo str, const LimitPath *node) -{ - WRITE_NODE_TYPE("LIMITPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_NODE_FIELD(limitOffset); - WRITE_NODE_FIELD(limitCount); - WRITE_ENUM_FIELD(limitOption, LimitOption); -} - -static void -_outGatherMergePath(StringInfo str, const GatherMergePath *node) -{ - WRITE_NODE_TYPE("GATHERMERGEPATH"); - - _outPathInfo(str, (const Path *) node); - - WRITE_NODE_FIELD(subpath); - WRITE_INT_FIELD(num_workers); -} - -static void -_outNestPath(StringInfo str, const NestPath *node) -{ - WRITE_NODE_TYPE("NESTPATH"); - - _outJoinPathInfo(str, (const JoinPath *) node); -} - -static void -_outMergePath(StringInfo str, const MergePath *node) -{ - WRITE_NODE_TYPE("MERGEPATH"); - - _outJoinPathInfo(str, (const JoinPath *) node); - - WRITE_NODE_FIELD(path_mergeclauses); - WRITE_NODE_FIELD(outersortkeys); - WRITE_NODE_FIELD(innersortkeys); - WRITE_BOOL_FIELD(skip_mark_restore); - WRITE_BOOL_FIELD(materialize_inner); -} - -static void -_outHashPath(StringInfo str, const HashPath *node) -{ - WRITE_NODE_TYPE("HASHPATH"); - - _outJoinPathInfo(str, (const JoinPath *) node); - - WRITE_NODE_FIELD(path_hashclauses); - WRITE_INT_FIELD(num_batches); - WRITE_FLOAT_FIELD(inner_rows_total, "%.0f"); -} - -static void -_outPlannerGlobal(StringInfo str, const PlannerGlobal *node) -{ - WRITE_NODE_TYPE("PLANNERGLOBAL"); - - /* NB: this isn't a complete set of fields */ - WRITE_NODE_FIELD(subplans); - WRITE_BITMAPSET_FIELD(rewindPlanIDs); - WRITE_NODE_FIELD(finalrtable); - WRITE_NODE_FIELD(finalrowmarks); - WRITE_NODE_FIELD(resultRelations); - WRITE_NODE_FIELD(appendRelations); - WRITE_NODE_FIELD(relationOids); - WRITE_NODE_FIELD(invalItems); - WRITE_NODE_FIELD(paramExecTypes); - WRITE_UINT_FIELD(lastPHId); - WRITE_UINT_FIELD(lastRowMarkId); - WRITE_INT_FIELD(lastPlanNodeId); - WRITE_BOOL_FIELD(transientPlan); - WRITE_BOOL_FIELD(dependsOnRole); - WRITE_BOOL_FIELD(parallelModeOK); - WRITE_BOOL_FIELD(parallelModeNeeded); - WRITE_CHAR_FIELD(maxParallelHazard); -} - -static void -_outPlannerInfo(StringInfo str, const PlannerInfo *node) -{ - WRITE_NODE_TYPE("PLANNERINFO"); - - /* NB: this isn't a complete set of fields */ - WRITE_NODE_FIELD(parse); - WRITE_NODE_FIELD(glob); - WRITE_UINT_FIELD(query_level); - WRITE_NODE_FIELD(plan_params); - WRITE_BITMAPSET_FIELD(outer_params); - WRITE_BITMAPSET_FIELD(all_baserels); - WRITE_BITMAPSET_FIELD(nullable_baserels); - WRITE_NODE_FIELD(join_rel_list); - WRITE_INT_FIELD(join_cur_level); - WRITE_NODE_FIELD(init_plans); - WRITE_NODE_FIELD(cte_plan_ids); - WRITE_NODE_FIELD(multiexpr_params); - WRITE_NODE_FIELD(eq_classes); - WRITE_BOOL_FIELD(ec_merging_done); - WRITE_NODE_FIELD(canon_pathkeys); - WRITE_NODE_FIELD(left_join_clauses); - WRITE_NODE_FIELD(right_join_clauses); - WRITE_NODE_FIELD(full_join_clauses); - WRITE_NODE_FIELD(join_info_list); - WRITE_BITMAPSET_FIELD(all_result_relids); - WRITE_BITMAPSET_FIELD(leaf_result_relids); - WRITE_NODE_FIELD(append_rel_list); - WRITE_NODE_FIELD(row_identity_vars); - WRITE_NODE_FIELD(rowMarks); - WRITE_NODE_FIELD(placeholder_list); - WRITE_NODE_FIELD(fkey_list); - WRITE_NODE_FIELD(query_pathkeys); - WRITE_NODE_FIELD(group_pathkeys); - WRITE_NODE_FIELD(window_pathkeys); - WRITE_NODE_FIELD(distinct_pathkeys); - WRITE_NODE_FIELD(sort_pathkeys); - WRITE_NODE_FIELD(processed_tlist); - WRITE_NODE_FIELD(update_colnos); - WRITE_NODE_FIELD(minmax_aggs); - WRITE_FLOAT_FIELD(total_table_pages, "%.0f"); - WRITE_FLOAT_FIELD(tuple_fraction, "%.4f"); - WRITE_FLOAT_FIELD(limit_tuples, "%.0f"); - WRITE_UINT_FIELD(qual_security_level); - WRITE_BOOL_FIELD(hasJoinRTEs); - WRITE_BOOL_FIELD(hasLateralRTEs); - WRITE_BOOL_FIELD(hasHavingQual); - WRITE_BOOL_FIELD(hasPseudoConstantQuals); - WRITE_BOOL_FIELD(hasAlternativeSubPlans); - WRITE_BOOL_FIELD(hasRecursion); - WRITE_INT_FIELD(wt_param_id); - WRITE_BITMAPSET_FIELD(curOuterRels); - WRITE_NODE_FIELD(curOuterParams); - WRITE_BOOL_FIELD(partColsUpdated); -} - -static void -_outRelOptInfo(StringInfo str, const RelOptInfo *node) -{ - WRITE_NODE_TYPE("RELOPTINFO"); - - /* NB: this isn't a complete set of fields */ - WRITE_ENUM_FIELD(reloptkind, RelOptKind); - WRITE_BITMAPSET_FIELD(relids); - WRITE_FLOAT_FIELD(rows, "%.0f"); - WRITE_BOOL_FIELD(consider_startup); - WRITE_BOOL_FIELD(consider_param_startup); - WRITE_BOOL_FIELD(consider_parallel); - WRITE_NODE_FIELD(reltarget); - WRITE_NODE_FIELD(pathlist); - WRITE_NODE_FIELD(ppilist); - WRITE_NODE_FIELD(partial_pathlist); - WRITE_NODE_FIELD(cheapest_startup_path); - WRITE_NODE_FIELD(cheapest_total_path); - WRITE_NODE_FIELD(cheapest_unique_path); - WRITE_NODE_FIELD(cheapest_parameterized_paths); - WRITE_BITMAPSET_FIELD(direct_lateral_relids); - WRITE_BITMAPSET_FIELD(lateral_relids); - WRITE_UINT_FIELD(relid); - WRITE_OID_FIELD(reltablespace); - WRITE_ENUM_FIELD(rtekind, RTEKind); - WRITE_INT_FIELD(min_attr); - WRITE_INT_FIELD(max_attr); - WRITE_NODE_FIELD(lateral_vars); - WRITE_BITMAPSET_FIELD(lateral_referencers); - WRITE_NODE_FIELD(indexlist); - WRITE_NODE_FIELD(statlist); - WRITE_UINT_FIELD(pages); - WRITE_FLOAT_FIELD(tuples, "%.0f"); - WRITE_FLOAT_FIELD(allvisfrac, "%.6f"); - WRITE_BITMAPSET_FIELD(eclass_indexes); - WRITE_NODE_FIELD(subroot); - WRITE_NODE_FIELD(subplan_params); - WRITE_INT_FIELD(rel_parallel_workers); - WRITE_UINT_FIELD(amflags); - WRITE_OID_FIELD(serverid); - WRITE_OID_FIELD(userid); - WRITE_BOOL_FIELD(useridiscurrent); - /* we don't try to print fdwroutine or fdw_private */ - /* can't print unique_for_rels/non_unique_for_rels; BMSes aren't Nodes */ - WRITE_NODE_FIELD(baserestrictinfo); - WRITE_UINT_FIELD(baserestrict_min_security); - WRITE_NODE_FIELD(joininfo); - WRITE_BOOL_FIELD(has_eclass_joins); - WRITE_BOOL_FIELD(consider_partitionwise_join); - WRITE_BITMAPSET_FIELD(top_parent_relids); - WRITE_BOOL_FIELD(partbounds_merged); - WRITE_BITMAPSET_FIELD(live_parts); - WRITE_BITMAPSET_FIELD(all_partrels); -} - -static void -_outIndexOptInfo(StringInfo str, const IndexOptInfo *node) -{ - WRITE_NODE_TYPE("INDEXOPTINFO"); - - /* NB: this isn't a complete set of fields */ - WRITE_OID_FIELD(indexoid); - /* Do NOT print rel field, else infinite recursion */ - WRITE_UINT_FIELD(pages); - WRITE_FLOAT_FIELD(tuples, "%.0f"); - WRITE_INT_FIELD(tree_height); - WRITE_INT_FIELD(ncolumns); - /* array fields aren't really worth the trouble to print */ - WRITE_OID_FIELD(relam); - /* indexprs is redundant since we print indextlist */ - WRITE_NODE_FIELD(indpred); - WRITE_NODE_FIELD(indextlist); - WRITE_NODE_FIELD(indrestrictinfo); - WRITE_BOOL_FIELD(predOK); - WRITE_BOOL_FIELD(unique); - WRITE_BOOL_FIELD(immediate); - WRITE_BOOL_FIELD(hypothetical); - /* we don't bother with fields copied from the index AM's API struct */ -} -#endif /* OBSOLETE */ - static void _outForeignKeyOptInfo(StringInfo str, const ForeignKeyOptInfo *node) { @@ -2603,20 +386,6 @@ _outForeignKeyOptInfo(StringInfo str, const ForeignKeyOptInfo *node) appendStringInfo(str, " %d", list_length(node->rinfos[i])); } -#ifdef OBSOLETE -static void -_outStatisticExtInfo(StringInfo str, const StatisticExtInfo *node) -{ - WRITE_NODE_TYPE("STATISTICEXTINFO"); - - /* NB: this isn't a complete set of fields */ - WRITE_OID_FIELD(statOid); - /* don't write rel, leads to infinite recursion in plan tree dump */ - WRITE_CHAR_FIELD(kind); - WRITE_BITMAPSET_FIELD(keys); -} -#endif /* OBSOLETE */ - static void _outEquivalenceClass(StringInfo str, const EquivalenceClass *node) { @@ -2644,199 +413,6 @@ _outEquivalenceClass(StringInfo str, const EquivalenceClass *node) WRITE_UINT_FIELD(ec_max_security); } -#ifdef OBSOLETE -static void -_outEquivalenceMember(StringInfo str, const EquivalenceMember *node) -{ - WRITE_NODE_TYPE("EQUIVALENCEMEMBER"); - - WRITE_NODE_FIELD(em_expr); - WRITE_BITMAPSET_FIELD(em_relids); - WRITE_BITMAPSET_FIELD(em_nullable_relids); - WRITE_BOOL_FIELD(em_is_const); - WRITE_BOOL_FIELD(em_is_child); - WRITE_OID_FIELD(em_datatype); -} - -static void -_outPathKey(StringInfo str, const PathKey *node) -{ - WRITE_NODE_TYPE("PATHKEY"); - - WRITE_NODE_FIELD(pk_eclass); - WRITE_OID_FIELD(pk_opfamily); - WRITE_INT_FIELD(pk_strategy); - WRITE_BOOL_FIELD(pk_nulls_first); -} - -static void -_outPathTarget(StringInfo str, const PathTarget *node) -{ - WRITE_NODE_TYPE("PATHTARGET"); - - WRITE_NODE_FIELD(exprs); - WRITE_INDEX_ARRAY(sortgrouprefs, list_length(node->exprs)); - WRITE_FLOAT_FIELD(cost.startup, "%.2f"); - WRITE_FLOAT_FIELD(cost.per_tuple, "%.2f"); - WRITE_INT_FIELD(width); - WRITE_ENUM_FIELD(has_volatile_expr, VolatileFunctionStatus); -} - -static void -_outParamPathInfo(StringInfo str, const ParamPathInfo *node) -{ - WRITE_NODE_TYPE("PARAMPATHINFO"); - - WRITE_BITMAPSET_FIELD(ppi_req_outer); - WRITE_FLOAT_FIELD(ppi_rows, "%.0f"); - WRITE_NODE_FIELD(ppi_clauses); -} - -static void -_outRestrictInfo(StringInfo str, const RestrictInfo *node) -{ - WRITE_NODE_TYPE("RESTRICTINFO"); - - /* NB: this isn't a complete set of fields */ - WRITE_NODE_FIELD(clause); - WRITE_BOOL_FIELD(is_pushed_down); - WRITE_BOOL_FIELD(outerjoin_delayed); - WRITE_BOOL_FIELD(can_join); - WRITE_BOOL_FIELD(pseudoconstant); - WRITE_BOOL_FIELD(leakproof); - WRITE_ENUM_FIELD(has_volatile, VolatileFunctionStatus); - WRITE_UINT_FIELD(security_level); - WRITE_BITMAPSET_FIELD(clause_relids); - WRITE_BITMAPSET_FIELD(required_relids); - WRITE_BITMAPSET_FIELD(outer_relids); - WRITE_BITMAPSET_FIELD(nullable_relids); - WRITE_BITMAPSET_FIELD(left_relids); - WRITE_BITMAPSET_FIELD(right_relids); - WRITE_NODE_FIELD(orclause); - /* don't write parent_ec, leads to infinite recursion in plan tree dump */ - WRITE_FLOAT_FIELD(norm_selec, "%.4f"); - WRITE_FLOAT_FIELD(outer_selec, "%.4f"); - WRITE_NODE_FIELD(mergeopfamilies); - /* don't write left_ec, leads to infinite recursion in plan tree dump */ - /* don't write right_ec, leads to infinite recursion in plan tree dump */ - WRITE_NODE_FIELD(left_em); - WRITE_NODE_FIELD(right_em); - WRITE_BOOL_FIELD(outer_is_left); - WRITE_OID_FIELD(hashjoinoperator); - WRITE_OID_FIELD(left_hasheqoperator); - WRITE_OID_FIELD(right_hasheqoperator); -} - -static void -_outIndexClause(StringInfo str, const IndexClause *node) -{ - WRITE_NODE_TYPE("INDEXCLAUSE"); - - WRITE_NODE_FIELD(rinfo); - WRITE_NODE_FIELD(indexquals); - WRITE_BOOL_FIELD(lossy); - WRITE_INT_FIELD(indexcol); - WRITE_NODE_FIELD(indexcols); -} - -static void -_outPlaceHolderVar(StringInfo str, const PlaceHolderVar *node) -{ - WRITE_NODE_TYPE("PLACEHOLDERVAR"); - - WRITE_NODE_FIELD(phexpr); - WRITE_BITMAPSET_FIELD(phrels); - WRITE_UINT_FIELD(phid); - WRITE_UINT_FIELD(phlevelsup); -} - -static void -_outSpecialJoinInfo(StringInfo str, const SpecialJoinInfo *node) -{ - WRITE_NODE_TYPE("SPECIALJOININFO"); - - WRITE_BITMAPSET_FIELD(min_lefthand); - WRITE_BITMAPSET_FIELD(min_righthand); - WRITE_BITMAPSET_FIELD(syn_lefthand); - WRITE_BITMAPSET_FIELD(syn_righthand); - WRITE_ENUM_FIELD(jointype, JoinType); - WRITE_BOOL_FIELD(lhs_strict); - WRITE_BOOL_FIELD(delay_upper_joins); - WRITE_BOOL_FIELD(semi_can_btree); - WRITE_BOOL_FIELD(semi_can_hash); - WRITE_NODE_FIELD(semi_operators); - WRITE_NODE_FIELD(semi_rhs_exprs); -} - -static void -_outAppendRelInfo(StringInfo str, const AppendRelInfo *node) -{ - WRITE_NODE_TYPE("APPENDRELINFO"); - - WRITE_UINT_FIELD(parent_relid); - WRITE_UINT_FIELD(child_relid); - WRITE_OID_FIELD(parent_reltype); - WRITE_OID_FIELD(child_reltype); - WRITE_NODE_FIELD(translated_vars); - WRITE_INT_FIELD(num_child_cols); - WRITE_ATTRNUMBER_ARRAY(parent_colnos, node->num_child_cols); - WRITE_OID_FIELD(parent_reloid); -} - -static void -_outRowIdentityVarInfo(StringInfo str, const RowIdentityVarInfo *node) -{ - WRITE_NODE_TYPE("ROWIDENTITYVARINFO"); - - WRITE_NODE_FIELD(rowidvar); - WRITE_INT_FIELD(rowidwidth); - WRITE_STRING_FIELD(rowidname); - WRITE_BITMAPSET_FIELD(rowidrels); -} - -static void -_outPlaceHolderInfo(StringInfo str, const PlaceHolderInfo *node) -{ - WRITE_NODE_TYPE("PLACEHOLDERINFO"); - - WRITE_UINT_FIELD(phid); - WRITE_NODE_FIELD(ph_var); - WRITE_BITMAPSET_FIELD(ph_eval_at); - WRITE_BITMAPSET_FIELD(ph_lateral); - WRITE_BITMAPSET_FIELD(ph_needed); - WRITE_INT_FIELD(ph_width); -} - -static void -_outMinMaxAggInfo(StringInfo str, const MinMaxAggInfo *node) -{ - WRITE_NODE_TYPE("MINMAXAGGINFO"); - - WRITE_OID_FIELD(aggfnoid); - WRITE_OID_FIELD(aggsortop); - WRITE_NODE_FIELD(target); - /* We intentionally omit subroot --- too large, not interesting enough */ - WRITE_NODE_FIELD(path); - WRITE_FLOAT_FIELD(pathcost, "%.2f"); - WRITE_NODE_FIELD(param); -} - -static void -_outPlannerParamItem(StringInfo str, const PlannerParamItem *node) -{ - WRITE_NODE_TYPE("PLANNERPARAMITEM"); - - WRITE_NODE_FIELD(item); - WRITE_INT_FIELD(paramId); -} -#endif /* OBSOLETE */ - -/***************************************************************************** - * - * Stuff from extensible.h - * - *****************************************************************************/ - static void _outExtensibleNode(StringInfo str, const ExtensibleNode *node) { @@ -2852,342 +428,6 @@ _outExtensibleNode(StringInfo str, const ExtensibleNode *node) methods->nodeOut(str, node); } -#ifdef OBSOLETE -/***************************************************************************** - * - * Stuff from parsenodes.h. - * - *****************************************************************************/ - -/* - * print the basic stuff of all nodes that inherit from CreateStmt - */ -static void -_outCreateStmtInfo(StringInfo str, const CreateStmt *node) -{ - WRITE_NODE_FIELD(relation); - WRITE_NODE_FIELD(tableElts); - WRITE_NODE_FIELD(inhRelations); - WRITE_NODE_FIELD(partspec); - WRITE_NODE_FIELD(partbound); - WRITE_NODE_FIELD(ofTypename); - WRITE_NODE_FIELD(constraints); - WRITE_NODE_FIELD(options); - WRITE_ENUM_FIELD(oncommit, OnCommitAction); - WRITE_STRING_FIELD(tablespacename); - WRITE_STRING_FIELD(accessMethod); - WRITE_BOOL_FIELD(if_not_exists); -} - -static void -_outCreateStmt(StringInfo str, const CreateStmt *node) -{ - WRITE_NODE_TYPE("CREATESTMT"); - - _outCreateStmtInfo(str, (const CreateStmt *) node); -} - -static void -_outCreateForeignTableStmt(StringInfo str, const CreateForeignTableStmt *node) -{ - WRITE_NODE_TYPE("CREATEFOREIGNTABLESTMT"); - - _outCreateStmtInfo(str, (const CreateStmt *) node); - - WRITE_STRING_FIELD(servername); - WRITE_NODE_FIELD(options); -} - -static void -_outImportForeignSchemaStmt(StringInfo str, const ImportForeignSchemaStmt *node) -{ - WRITE_NODE_TYPE("IMPORTFOREIGNSCHEMASTMT"); - - WRITE_STRING_FIELD(server_name); - WRITE_STRING_FIELD(remote_schema); - WRITE_STRING_FIELD(local_schema); - WRITE_ENUM_FIELD(list_type, ImportForeignSchemaType); - WRITE_NODE_FIELD(table_list); - WRITE_NODE_FIELD(options); -} - -static void -_outIndexStmt(StringInfo str, const IndexStmt *node) -{ - WRITE_NODE_TYPE("INDEXSTMT"); - - WRITE_STRING_FIELD(idxname); - WRITE_NODE_FIELD(relation); - WRITE_STRING_FIELD(accessMethod); - WRITE_STRING_FIELD(tableSpace); - WRITE_NODE_FIELD(indexParams); - WRITE_NODE_FIELD(indexIncludingParams); - WRITE_NODE_FIELD(options); - WRITE_NODE_FIELD(whereClause); - WRITE_NODE_FIELD(excludeOpNames); - WRITE_STRING_FIELD(idxcomment); - WRITE_OID_FIELD(indexOid); - WRITE_OID_FIELD(oldNumber); - WRITE_UINT_FIELD(oldCreateSubid); - WRITE_UINT_FIELD(oldFirstRelfilelocatorSubid); - WRITE_BOOL_FIELD(unique); - WRITE_BOOL_FIELD(nulls_not_distinct); - WRITE_BOOL_FIELD(primary); - WRITE_BOOL_FIELD(isconstraint); - WRITE_BOOL_FIELD(deferrable); - WRITE_BOOL_FIELD(initdeferred); - WRITE_BOOL_FIELD(transformed); - WRITE_BOOL_FIELD(concurrent); - WRITE_BOOL_FIELD(if_not_exists); - WRITE_BOOL_FIELD(reset_default_tblspc); -} - -static void -_outCreateStatsStmt(StringInfo str, const CreateStatsStmt *node) -{ - WRITE_NODE_TYPE("CREATESTATSSTMT"); - - WRITE_NODE_FIELD(defnames); - WRITE_NODE_FIELD(stat_types); - WRITE_NODE_FIELD(exprs); - WRITE_NODE_FIELD(relations); - WRITE_STRING_FIELD(stxcomment); - WRITE_BOOL_FIELD(transformed); - WRITE_BOOL_FIELD(if_not_exists); -} - -static void -_outAlterStatsStmt(StringInfo str, const AlterStatsStmt *node) -{ - WRITE_NODE_TYPE("ALTERSTATSSTMT"); - - WRITE_NODE_FIELD(defnames); - WRITE_INT_FIELD(stxstattarget); - WRITE_BOOL_FIELD(missing_ok); -} - -static void -_outNotifyStmt(StringInfo str, const NotifyStmt *node) -{ - WRITE_NODE_TYPE("NOTIFYSTMT"); - - WRITE_STRING_FIELD(conditionname); - WRITE_STRING_FIELD(payload); -} - -static void -_outDeclareCursorStmt(StringInfo str, const DeclareCursorStmt *node) -{ - WRITE_NODE_TYPE("DECLARECURSORSTMT"); - - WRITE_STRING_FIELD(portalname); - WRITE_INT_FIELD(options); - WRITE_NODE_FIELD(query); -} - -static void -_outSelectStmt(StringInfo str, const SelectStmt *node) -{ - WRITE_NODE_TYPE("SELECT"); - - WRITE_NODE_FIELD(distinctClause); - WRITE_NODE_FIELD(intoClause); - WRITE_NODE_FIELD(targetList); - WRITE_NODE_FIELD(fromClause); - WRITE_NODE_FIELD(whereClause); - WRITE_NODE_FIELD(groupClause); - WRITE_BOOL_FIELD(groupDistinct); - WRITE_NODE_FIELD(havingClause); - WRITE_NODE_FIELD(windowClause); - WRITE_NODE_FIELD(valuesLists); - WRITE_NODE_FIELD(sortClause); - WRITE_NODE_FIELD(limitOffset); - WRITE_NODE_FIELD(limitCount); - WRITE_ENUM_FIELD(limitOption, LimitOption); - WRITE_NODE_FIELD(lockingClause); - WRITE_NODE_FIELD(withClause); - WRITE_ENUM_FIELD(op, SetOperation); - WRITE_BOOL_FIELD(all); - WRITE_NODE_FIELD(larg); - WRITE_NODE_FIELD(rarg); -} - -static void -_outReturnStmt(StringInfo str, const ReturnStmt *node) -{ - WRITE_NODE_TYPE("RETURN"); - - WRITE_NODE_FIELD(returnval); -} - -static void -_outPLAssignStmt(StringInfo str, const PLAssignStmt *node) -{ - WRITE_NODE_TYPE("PLASSIGN"); - - WRITE_STRING_FIELD(name); - WRITE_NODE_FIELD(indirection); - WRITE_INT_FIELD(nnames); - WRITE_NODE_FIELD(val); - WRITE_LOCATION_FIELD(location); -} - -static void -_outFuncCall(StringInfo str, const FuncCall *node) -{ - WRITE_NODE_TYPE("FUNCCALL"); - - WRITE_NODE_FIELD(funcname); - WRITE_NODE_FIELD(args); - WRITE_NODE_FIELD(agg_order); - WRITE_NODE_FIELD(agg_filter); - WRITE_NODE_FIELD(over); - WRITE_BOOL_FIELD(agg_within_group); - WRITE_BOOL_FIELD(agg_star); - WRITE_BOOL_FIELD(agg_distinct); - WRITE_BOOL_FIELD(func_variadic); - WRITE_ENUM_FIELD(funcformat, CoercionForm); - WRITE_LOCATION_FIELD(location); -} - -static void -_outDefElem(StringInfo str, const DefElem *node) -{ - WRITE_NODE_TYPE("DEFELEM"); - - WRITE_STRING_FIELD(defnamespace); - WRITE_STRING_FIELD(defname); - WRITE_NODE_FIELD(arg); - WRITE_ENUM_FIELD(defaction, DefElemAction); - WRITE_LOCATION_FIELD(location); -} - -static void -_outTableLikeClause(StringInfo str, const TableLikeClause *node) -{ - WRITE_NODE_TYPE("TABLELIKECLAUSE"); - - WRITE_NODE_FIELD(relation); - WRITE_UINT_FIELD(options); - WRITE_OID_FIELD(relationOid); -} - -static void -_outLockingClause(StringInfo str, const LockingClause *node) -{ - WRITE_NODE_TYPE("LOCKINGCLAUSE"); - - WRITE_NODE_FIELD(lockedRels); - WRITE_ENUM_FIELD(strength, LockClauseStrength); - WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy); -} - -static void -_outXmlSerialize(StringInfo str, const XmlSerialize *node) -{ - WRITE_NODE_TYPE("XMLSERIALIZE"); - - WRITE_ENUM_FIELD(xmloption, XmlOptionType); - WRITE_NODE_FIELD(expr); - WRITE_NODE_FIELD(typeName); - WRITE_LOCATION_FIELD(location); -} - -static void -_outTriggerTransition(StringInfo str, const TriggerTransition *node) -{ - WRITE_NODE_TYPE("TRIGGERTRANSITION"); - - WRITE_STRING_FIELD(name); - WRITE_BOOL_FIELD(isNew); - WRITE_BOOL_FIELD(isTable); -} - -static void -_outColumnDef(StringInfo str, const ColumnDef *node) -{ - WRITE_NODE_TYPE("COLUMNDEF"); - - WRITE_STRING_FIELD(colname); - WRITE_NODE_FIELD(typeName); - WRITE_STRING_FIELD(compression); - WRITE_INT_FIELD(inhcount); - WRITE_BOOL_FIELD(is_local); - WRITE_BOOL_FIELD(is_not_null); - WRITE_BOOL_FIELD(is_from_type); - WRITE_CHAR_FIELD(storage); - WRITE_NODE_FIELD(raw_default); - WRITE_NODE_FIELD(cooked_default); - WRITE_CHAR_FIELD(identity); - WRITE_NODE_FIELD(identitySequence); - WRITE_CHAR_FIELD(generated); - WRITE_NODE_FIELD(collClause); - WRITE_OID_FIELD(collOid); - WRITE_NODE_FIELD(constraints); - WRITE_NODE_FIELD(fdwoptions); - WRITE_LOCATION_FIELD(location); -} - -static void -_outTypeName(StringInfo str, const TypeName *node) -{ - WRITE_NODE_TYPE("TYPENAME"); - - WRITE_NODE_FIELD(names); - WRITE_OID_FIELD(typeOid); - WRITE_BOOL_FIELD(setof); - WRITE_BOOL_FIELD(pct_type); - WRITE_NODE_FIELD(typmods); - WRITE_INT_FIELD(typemod); - WRITE_NODE_FIELD(arrayBounds); - WRITE_LOCATION_FIELD(location); -} - -static void -_outTypeCast(StringInfo str, const TypeCast *node) -{ - WRITE_NODE_TYPE("TYPECAST"); - - WRITE_NODE_FIELD(arg); - WRITE_NODE_FIELD(typeName); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCollateClause(StringInfo str, const CollateClause *node) -{ - WRITE_NODE_TYPE("COLLATECLAUSE"); - - WRITE_NODE_FIELD(arg); - WRITE_NODE_FIELD(collname); - WRITE_LOCATION_FIELD(location); -} - -static void -_outIndexElem(StringInfo str, const IndexElem *node) -{ - WRITE_NODE_TYPE("INDEXELEM"); - - WRITE_STRING_FIELD(name); - WRITE_NODE_FIELD(expr); - WRITE_STRING_FIELD(indexcolname); - WRITE_NODE_FIELD(collation); - WRITE_NODE_FIELD(opclass); - WRITE_NODE_FIELD(opclassopts); - WRITE_ENUM_FIELD(ordering, SortByDir); - WRITE_ENUM_FIELD(nulls_ordering, SortByNulls); -} - -static void -_outStatsElem(StringInfo str, const StatsElem *node) -{ - WRITE_NODE_TYPE("STATSELEM"); - - WRITE_STRING_FIELD(name); - WRITE_NODE_FIELD(expr); -} -#endif /* OBSOLETE */ - static void _outQuery(StringInfo str, const Query *node) { @@ -3261,174 +501,6 @@ _outQuery(StringInfo str, const Query *node) WRITE_INT_FIELD(stmt_len); } -#ifdef OBSOLETE -static void -_outWithCheckOption(StringInfo str, const WithCheckOption *node) -{ - WRITE_NODE_TYPE("WITHCHECKOPTION"); - - WRITE_ENUM_FIELD(kind, WCOKind); - WRITE_STRING_FIELD(relname); - WRITE_STRING_FIELD(polname); - WRITE_NODE_FIELD(qual); - WRITE_BOOL_FIELD(cascaded); -} - -static void -_outSortGroupClause(StringInfo str, const SortGroupClause *node) -{ - WRITE_NODE_TYPE("SORTGROUPCLAUSE"); - - WRITE_UINT_FIELD(tleSortGroupRef); - WRITE_OID_FIELD(eqop); - WRITE_OID_FIELD(sortop); - WRITE_BOOL_FIELD(nulls_first); - WRITE_BOOL_FIELD(hashable); -} - -static void -_outGroupingSet(StringInfo str, const GroupingSet *node) -{ - WRITE_NODE_TYPE("GROUPINGSET"); - - WRITE_ENUM_FIELD(kind, GroupingSetKind); - WRITE_NODE_FIELD(content); - WRITE_LOCATION_FIELD(location); -} - -static void -_outWindowClause(StringInfo str, const WindowClause *node) -{ - WRITE_NODE_TYPE("WINDOWCLAUSE"); - - WRITE_STRING_FIELD(name); - WRITE_STRING_FIELD(refname); - WRITE_NODE_FIELD(partitionClause); - WRITE_NODE_FIELD(orderClause); - WRITE_INT_FIELD(frameOptions); - WRITE_NODE_FIELD(startOffset); - WRITE_NODE_FIELD(endOffset); - WRITE_NODE_FIELD(runCondition); - WRITE_OID_FIELD(startInRangeFunc); - WRITE_OID_FIELD(endInRangeFunc); - WRITE_OID_FIELD(inRangeColl); - WRITE_BOOL_FIELD(inRangeAsc); - WRITE_BOOL_FIELD(inRangeNullsFirst); - WRITE_UINT_FIELD(winref); - WRITE_BOOL_FIELD(copiedOrder); -} - -static void -_outRowMarkClause(StringInfo str, const RowMarkClause *node) -{ - WRITE_NODE_TYPE("ROWMARKCLAUSE"); - - WRITE_UINT_FIELD(rti); - WRITE_ENUM_FIELD(strength, LockClauseStrength); - WRITE_ENUM_FIELD(waitPolicy, LockWaitPolicy); - WRITE_BOOL_FIELD(pushedDown); -} - -static void -_outWithClause(StringInfo str, const WithClause *node) -{ - WRITE_NODE_TYPE("WITHCLAUSE"); - - WRITE_NODE_FIELD(ctes); - WRITE_BOOL_FIELD(recursive); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCTESearchClause(StringInfo str, const CTESearchClause *node) -{ - WRITE_NODE_TYPE("CTESEARCHCLAUSE"); - - WRITE_NODE_FIELD(search_col_list); - WRITE_BOOL_FIELD(search_breadth_first); - WRITE_STRING_FIELD(search_seq_column); - WRITE_LOCATION_FIELD(location); -} - -static void -_outCTECycleClause(StringInfo str, const CTECycleClause *node) -{ - WRITE_NODE_TYPE("CTECYCLECLAUSE"); - - WRITE_NODE_FIELD(cycle_col_list); - WRITE_STRING_FIELD(cycle_mark_column); - WRITE_NODE_FIELD(cycle_mark_value); - WRITE_NODE_FIELD(cycle_mark_default); - WRITE_STRING_FIELD(cycle_path_column); - WRITE_LOCATION_FIELD(location); - WRITE_OID_FIELD(cycle_mark_type); - WRITE_INT_FIELD(cycle_mark_typmod); - WRITE_OID_FIELD(cycle_mark_collation); - WRITE_OID_FIELD(cycle_mark_neop); -} - -static void -_outCommonTableExpr(StringInfo str, const CommonTableExpr *node) -{ - WRITE_NODE_TYPE("COMMONTABLEEXPR"); - - WRITE_STRING_FIELD(ctename); - WRITE_NODE_FIELD(aliascolnames); - WRITE_ENUM_FIELD(ctematerialized, CTEMaterialize); - WRITE_NODE_FIELD(ctequery); - WRITE_NODE_FIELD(search_clause); - WRITE_NODE_FIELD(cycle_clause); - WRITE_LOCATION_FIELD(location); - WRITE_BOOL_FIELD(cterecursive); - WRITE_INT_FIELD(cterefcount); - WRITE_NODE_FIELD(ctecolnames); - WRITE_NODE_FIELD(ctecoltypes); - WRITE_NODE_FIELD(ctecoltypmods); - WRITE_NODE_FIELD(ctecolcollations); -} - -static void -_outMergeWhenClause(StringInfo str, const MergeWhenClause *node) -{ - WRITE_NODE_TYPE("MERGEWHENCLAUSE"); - - WRITE_BOOL_FIELD(matched); - WRITE_ENUM_FIELD(commandType, CmdType); - WRITE_ENUM_FIELD(override, OverridingKind); - WRITE_NODE_FIELD(condition); - WRITE_NODE_FIELD(targetList); - WRITE_NODE_FIELD(values); -} - -static void -_outMergeAction(StringInfo str, const MergeAction *node) -{ - WRITE_NODE_TYPE("MERGEACTION"); - - WRITE_BOOL_FIELD(matched); - WRITE_ENUM_FIELD(commandType, CmdType); - WRITE_ENUM_FIELD(override, OverridingKind); - WRITE_NODE_FIELD(qual); - WRITE_NODE_FIELD(targetList); - WRITE_NODE_FIELD(updateColnos); -} - -static void -_outSetOperationStmt(StringInfo str, const SetOperationStmt *node) -{ - WRITE_NODE_TYPE("SETOPERATIONSTMT"); - - WRITE_ENUM_FIELD(op, SetOperation); - WRITE_BOOL_FIELD(all); - WRITE_NODE_FIELD(larg); - WRITE_NODE_FIELD(rarg); - WRITE_NODE_FIELD(colTypes); - WRITE_NODE_FIELD(colTypmods); - WRITE_NODE_FIELD(colCollations); - WRITE_NODE_FIELD(groupClauses); -} -#endif /* OBSOLETE */ - static void _outRangeTblEntry(StringInfo str, const RangeTblEntry *node) { @@ -3508,32 +580,6 @@ _outRangeTblEntry(StringInfo str, const RangeTblEntry *node) WRITE_NODE_FIELD(securityQuals); } -#ifdef OBSOLETE -static void -_outRangeTblFunction(StringInfo str, const RangeTblFunction *node) -{ - WRITE_NODE_TYPE("RANGETBLFUNCTION"); - - WRITE_NODE_FIELD(funcexpr); - WRITE_INT_FIELD(funccolcount); - WRITE_NODE_FIELD(funccolnames); - WRITE_NODE_FIELD(funccoltypes); - WRITE_NODE_FIELD(funccoltypmods); - WRITE_NODE_FIELD(funccolcollations); - WRITE_BITMAPSET_FIELD(funcparams); -} - -static void -_outTableSampleClause(StringInfo str, const TableSampleClause *node) -{ - WRITE_NODE_TYPE("TABLESAMPLECLAUSE"); - - WRITE_OID_FIELD(tsmhandler); - WRITE_NODE_FIELD(args); - WRITE_NODE_FIELD(repeatable); -} -#endif /* OBSOLETE */ - static void _outA_Expr(StringInfo str, const A_Expr *node) { @@ -3651,40 +697,6 @@ _outBitString(StringInfo str, const BitString *node) appendStringInfoString(str, node->bsval); } -#ifdef OBSOLETE -static void -_outColumnRef(StringInfo str, const ColumnRef *node) -{ - WRITE_NODE_TYPE("COLUMNREF"); - - WRITE_NODE_FIELD(fields); - WRITE_LOCATION_FIELD(location); -} - -static void -_outParamRef(StringInfo str, const ParamRef *node) -{ - WRITE_NODE_TYPE("PARAMREF"); - - WRITE_INT_FIELD(number); - WRITE_LOCATION_FIELD(location); -} - -/* - * Node types found in raw parse trees (supported for debug purposes) - */ - -static void -_outRawStmt(StringInfo str, const RawStmt *node) -{ - WRITE_NODE_TYPE("RAWSTMT"); - - WRITE_NODE_FIELD(stmt); - WRITE_LOCATION_FIELD(stmt_location); - WRITE_INT_FIELD(stmt_len); -} -#endif /* OBSOLETE */ - static void _outA_Const(StringInfo str, const A_Const *node) { @@ -3700,153 +712,6 @@ _outA_Const(StringInfo str, const A_Const *node) WRITE_LOCATION_FIELD(location); } -#ifdef OBSOLETE -static void -_outA_Star(StringInfo str, const A_Star *node) -{ - WRITE_NODE_TYPE("A_STAR"); -} - -static void -_outA_Indices(StringInfo str, const A_Indices *node) -{ - WRITE_NODE_TYPE("A_INDICES"); - - WRITE_BOOL_FIELD(is_slice); - WRITE_NODE_FIELD(lidx); - WRITE_NODE_FIELD(uidx); -} - -static void -_outA_Indirection(StringInfo str, const A_Indirection *node) -{ - WRITE_NODE_TYPE("A_INDIRECTION"); - - WRITE_NODE_FIELD(arg); - WRITE_NODE_FIELD(indirection); -} - -static void -_outA_ArrayExpr(StringInfo str, const A_ArrayExpr *node) -{ - WRITE_NODE_TYPE("A_ARRAYEXPR"); - - WRITE_NODE_FIELD(elements); - WRITE_LOCATION_FIELD(location); -} - -static void -_outResTarget(StringInfo str, const ResTarget *node) -{ - WRITE_NODE_TYPE("RESTARGET"); - - WRITE_STRING_FIELD(name); - WRITE_NODE_FIELD(indirection); - WRITE_NODE_FIELD(val); - WRITE_LOCATION_FIELD(location); -} - -static void -_outMultiAssignRef(StringInfo str, const MultiAssignRef *node) -{ - WRITE_NODE_TYPE("MULTIASSIGNREF"); - - WRITE_NODE_FIELD(source); - WRITE_INT_FIELD(colno); - WRITE_INT_FIELD(ncolumns); -} - -static void -_outSortBy(StringInfo str, const SortBy *node) -{ - WRITE_NODE_TYPE("SORTBY"); - - WRITE_NODE_FIELD(node); - WRITE_ENUM_FIELD(sortby_dir, SortByDir); - WRITE_ENUM_FIELD(sortby_nulls, SortByNulls); - WRITE_NODE_FIELD(useOp); - WRITE_LOCATION_FIELD(location); -} - -static void -_outWindowDef(StringInfo str, const WindowDef *node) -{ - WRITE_NODE_TYPE("WINDOWDEF"); - - WRITE_STRING_FIELD(name); - WRITE_STRING_FIELD(refname); - WRITE_NODE_FIELD(partitionClause); - WRITE_NODE_FIELD(orderClause); - WRITE_INT_FIELD(frameOptions); - WRITE_NODE_FIELD(startOffset); - WRITE_NODE_FIELD(endOffset); - WRITE_LOCATION_FIELD(location); -} - -static void -_outRangeSubselect(StringInfo str, const RangeSubselect *node) -{ - WRITE_NODE_TYPE("RANGESUBSELECT"); - - WRITE_BOOL_FIELD(lateral); - WRITE_NODE_FIELD(subquery); - WRITE_NODE_FIELD(alias); -} - -static void -_outRangeFunction(StringInfo str, const RangeFunction *node) -{ - WRITE_NODE_TYPE("RANGEFUNCTION"); - - WRITE_BOOL_FIELD(lateral); - WRITE_BOOL_FIELD(ordinality); - WRITE_BOOL_FIELD(is_rowsfrom); - WRITE_NODE_FIELD(functions); - WRITE_NODE_FIELD(alias); - WRITE_NODE_FIELD(coldeflist); -} - -static void -_outRangeTableSample(StringInfo str, const RangeTableSample *node) -{ - WRITE_NODE_TYPE("RANGETABLESAMPLE"); - - WRITE_NODE_FIELD(relation); - WRITE_NODE_FIELD(method); - WRITE_NODE_FIELD(args); - WRITE_NODE_FIELD(repeatable); - WRITE_LOCATION_FIELD(location); -} - -static void -_outRangeTableFunc(StringInfo str, const RangeTableFunc *node) -{ - WRITE_NODE_TYPE("RANGETABLEFUNC"); - - WRITE_BOOL_FIELD(lateral); - WRITE_NODE_FIELD(docexpr); - WRITE_NODE_FIELD(rowexpr); - WRITE_NODE_FIELD(namespaces); - WRITE_NODE_FIELD(columns); - WRITE_NODE_FIELD(alias); - WRITE_LOCATION_FIELD(location); -} - -static void -_outRangeTableFuncCol(StringInfo str, const RangeTableFuncCol *node) -{ - WRITE_NODE_TYPE("RANGETABLEFUNCCOL"); - - WRITE_STRING_FIELD(colname); - WRITE_NODE_FIELD(typeName); - WRITE_BOOL_FIELD(for_ordinality); - WRITE_BOOL_FIELD(is_not_null); - WRITE_NODE_FIELD(colexpr); - WRITE_NODE_FIELD(coldefexpr); - WRITE_LOCATION_FIELD(location); -} -#endif /* OBSOLETE */ - static void _outConstraint(StringInfo str, const Constraint *node) { @@ -3968,68 +833,6 @@ _outConstraint(StringInfo str, const Constraint *node) } } -#ifdef OBSOLETE -static void -_outForeignKeyCacheInfo(StringInfo str, const ForeignKeyCacheInfo *node) -{ - WRITE_NODE_TYPE("FOREIGNKEYCACHEINFO"); - - WRITE_OID_FIELD(conoid); - WRITE_OID_FIELD(conrelid); - WRITE_OID_FIELD(confrelid); - WRITE_INT_FIELD(nkeys); - WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys); - WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys); - WRITE_OID_ARRAY(conpfeqop, node->nkeys); -} - -static void -_outPartitionElem(StringInfo str, const PartitionElem *node) -{ - WRITE_NODE_TYPE("PARTITIONELEM"); - - WRITE_STRING_FIELD(name); - WRITE_NODE_FIELD(expr); - WRITE_NODE_FIELD(collation); - WRITE_NODE_FIELD(opclass); - WRITE_LOCATION_FIELD(location); -} - -static void -_outPartitionSpec(StringInfo str, const PartitionSpec *node) -{ - WRITE_NODE_TYPE("PARTITIONSPEC"); - - WRITE_STRING_FIELD(strategy); - WRITE_NODE_FIELD(partParams); - WRITE_LOCATION_FIELD(location); -} - -static void -_outPartitionBoundSpec(StringInfo str, const PartitionBoundSpec *node) -{ - WRITE_NODE_TYPE("PARTITIONBOUNDSPEC"); - - WRITE_CHAR_FIELD(strategy); - WRITE_BOOL_FIELD(is_default); - WRITE_INT_FIELD(modulus); - WRITE_INT_FIELD(remainder); - WRITE_NODE_FIELD(listdatums); - WRITE_NODE_FIELD(lowerdatums); - WRITE_NODE_FIELD(upperdatums); - WRITE_LOCATION_FIELD(location); -} - -static void -_outPartitionRangeDatum(StringInfo str, const PartitionRangeDatum *node) -{ - WRITE_NODE_TYPE("PARTITIONRANGEDATUM"); - - WRITE_ENUM_FIELD(kind, PartitionRangeDatumKind); - WRITE_NODE_FIELD(value); - WRITE_LOCATION_FIELD(location); -} -#endif /* OBSOLETE */ /* * outNode - @@ -4062,713 +865,6 @@ outNode(StringInfo str, const void *obj) switch (nodeTag(obj)) { #include "outfuncs.switch.c" -#ifdef OBSOLETE - case T_PlannedStmt: - _outPlannedStmt(str, obj); - break; - case T_Result: - _outResult(str, obj); - break; - case T_ProjectSet: - _outProjectSet(str, obj); - break; - case T_ModifyTable: - _outModifyTable(str, obj); - break; - case T_Append: - _outAppend(str, obj); - break; - case T_MergeAppend: - _outMergeAppend(str, obj); - break; - case T_RecursiveUnion: - _outRecursiveUnion(str, obj); - break; - case T_BitmapAnd: - _outBitmapAnd(str, obj); - break; - case T_BitmapOr: - _outBitmapOr(str, obj); - break; - case T_Gather: - _outGather(str, obj); - break; - case T_GatherMerge: - _outGatherMerge(str, obj); - break; - case T_Scan: - _outScan(str, obj); - break; - case T_SeqScan: - _outSeqScan(str, obj); - break; - case T_SampleScan: - _outSampleScan(str, obj); - break; - case T_IndexScan: - _outIndexScan(str, obj); - break; - case T_IndexOnlyScan: - _outIndexOnlyScan(str, obj); - break; - case T_BitmapIndexScan: - _outBitmapIndexScan(str, obj); - break; - case T_BitmapHeapScan: - _outBitmapHeapScan(str, obj); - break; - case T_TidScan: - _outTidScan(str, obj); - break; - case T_TidRangeScan: - _outTidRangeScan(str, obj); - break; - case T_SubqueryScan: - _outSubqueryScan(str, obj); - break; - case T_FunctionScan: - _outFunctionScan(str, obj); - break; - case T_TableFuncScan: - _outTableFuncScan(str, obj); - break; - case T_ValuesScan: - _outValuesScan(str, obj); - break; - case T_CteScan: - _outCteScan(str, obj); - break; - case T_NamedTuplestoreScan: - _outNamedTuplestoreScan(str, obj); - break; - case T_WorkTableScan: - _outWorkTableScan(str, obj); - break; - case T_ForeignScan: - _outForeignScan(str, obj); - break; - case T_CustomScan: - _outCustomScan(str, obj); - break; - case T_NestLoop: - _outNestLoop(str, obj); - break; - case T_MergeJoin: - _outMergeJoin(str, obj); - break; - case T_HashJoin: - _outHashJoin(str, obj); - break; - case T_Agg: - _outAgg(str, obj); - break; - case T_WindowAgg: - _outWindowAgg(str, obj); - break; - case T_Group: - _outGroup(str, obj); - break; - case T_Material: - _outMaterial(str, obj); - break; - case T_Memoize: - _outMemoize(str, obj); - break; - case T_Sort: - _outSort(str, obj); - break; - case T_IncrementalSort: - _outIncrementalSort(str, obj); - break; - case T_Unique: - _outUnique(str, obj); - break; - case T_Hash: - _outHash(str, obj); - break; - case T_SetOp: - _outSetOp(str, obj); - break; - case T_LockRows: - _outLockRows(str, obj); - break; - case T_Limit: - _outLimit(str, obj); - break; - case T_NestLoopParam: - _outNestLoopParam(str, obj); - break; - case T_PlanRowMark: - _outPlanRowMark(str, obj); - break; - case T_PartitionPruneInfo: - _outPartitionPruneInfo(str, obj); - break; - case T_PartitionedRelPruneInfo: - _outPartitionedRelPruneInfo(str, obj); - break; - case T_PartitionPruneStepOp: - _outPartitionPruneStepOp(str, obj); - break; - case T_PartitionPruneStepCombine: - _outPartitionPruneStepCombine(str, obj); - break; - case T_PlanInvalItem: - _outPlanInvalItem(str, obj); - break; - case T_Alias: - _outAlias(str, obj); - break; - case T_RangeVar: - _outRangeVar(str, obj); - break; - case T_TableFunc: - _outTableFunc(str, obj); - break; - case T_IntoClause: - _outIntoClause(str, obj); - break; - case T_Var: - _outVar(str, obj); - break; - case T_Const: - _outConst(str, obj); - break; - case T_Param: - _outParam(str, obj); - break; - case T_Aggref: - _outAggref(str, obj); - break; - case T_GroupingFunc: - _outGroupingFunc(str, obj); - break; - case T_WindowFunc: - _outWindowFunc(str, obj); - break; - case T_SubscriptingRef: - _outSubscriptingRef(str, obj); - break; - case T_FuncExpr: - _outFuncExpr(str, obj); - break; - case T_NamedArgExpr: - _outNamedArgExpr(str, obj); - break; - case T_OpExpr: - _outOpExpr(str, obj); - break; - case T_DistinctExpr: - _outDistinctExpr(str, obj); - break; - case T_NullIfExpr: - _outNullIfExpr(str, obj); - break; - case T_ScalarArrayOpExpr: - _outScalarArrayOpExpr(str, obj); - break; - case T_BoolExpr: - _outBoolExpr(str, obj); - break; - case T_SubLink: - _outSubLink(str, obj); - break; - case T_SubPlan: - _outSubPlan(str, obj); - break; - case T_AlternativeSubPlan: - _outAlternativeSubPlan(str, obj); - break; - case T_FieldSelect: - _outFieldSelect(str, obj); - break; - case T_FieldStore: - _outFieldStore(str, obj); - break; - case T_RelabelType: - _outRelabelType(str, obj); - break; - case T_CoerceViaIO: - _outCoerceViaIO(str, obj); - break; - case T_ArrayCoerceExpr: - _outArrayCoerceExpr(str, obj); - break; - case T_ConvertRowtypeExpr: - _outConvertRowtypeExpr(str, obj); - break; - case T_CollateExpr: - _outCollateExpr(str, obj); - break; - case T_CaseExpr: - _outCaseExpr(str, obj); - break; - case T_CaseWhen: - _outCaseWhen(str, obj); - break; - case T_CaseTestExpr: - _outCaseTestExpr(str, obj); - break; - case T_ArrayExpr: - _outArrayExpr(str, obj); - break; - case T_RowExpr: - _outRowExpr(str, obj); - break; - case T_RowCompareExpr: - _outRowCompareExpr(str, obj); - break; - case T_CoalesceExpr: - _outCoalesceExpr(str, obj); - break; - case T_MinMaxExpr: - _outMinMaxExpr(str, obj); - break; - case T_SQLValueFunction: - _outSQLValueFunction(str, obj); - break; - case T_XmlExpr: - _outXmlExpr(str, obj); - break; - case T_NullTest: - _outNullTest(str, obj); - break; - case T_BooleanTest: - _outBooleanTest(str, obj); - break; - case T_CoerceToDomain: - _outCoerceToDomain(str, obj); - break; - case T_CoerceToDomainValue: - _outCoerceToDomainValue(str, obj); - break; - case T_SetToDefault: - _outSetToDefault(str, obj); - break; - case T_CurrentOfExpr: - _outCurrentOfExpr(str, obj); - break; - case T_NextValueExpr: - _outNextValueExpr(str, obj); - break; - case T_InferenceElem: - _outInferenceElem(str, obj); - break; - case T_TargetEntry: - _outTargetEntry(str, obj); - break; - case T_RangeTblRef: - _outRangeTblRef(str, obj); - break; - case T_JoinExpr: - _outJoinExpr(str, obj); - break; - case T_FromExpr: - _outFromExpr(str, obj); - break; - case T_OnConflictExpr: - _outOnConflictExpr(str, obj); - break; - case T_Path: - _outPath(str, obj); - break; - case T_IndexPath: - _outIndexPath(str, obj); - break; - case T_BitmapHeapPath: - _outBitmapHeapPath(str, obj); - break; - case T_BitmapAndPath: - _outBitmapAndPath(str, obj); - break; - case T_BitmapOrPath: - _outBitmapOrPath(str, obj); - break; - case T_TidPath: - _outTidPath(str, obj); - break; - case T_TidRangePath: - _outTidRangePath(str, obj); - break; - case T_SubqueryScanPath: - _outSubqueryScanPath(str, obj); - break; - case T_ForeignPath: - _outForeignPath(str, obj); - break; - case T_CustomPath: - _outCustomPath(str, obj); - break; - case T_AppendPath: - _outAppendPath(str, obj); - break; - case T_MergeAppendPath: - _outMergeAppendPath(str, obj); - break; - case T_GroupResultPath: - _outGroupResultPath(str, obj); - break; - case T_MaterialPath: - _outMaterialPath(str, obj); - break; - case T_MemoizePath: - _outMemoizePath(str, obj); - break; - case T_UniquePath: - _outUniquePath(str, obj); - break; - case T_GatherPath: - _outGatherPath(str, obj); - break; - case T_ProjectionPath: - _outProjectionPath(str, obj); - break; - case T_ProjectSetPath: - _outProjectSetPath(str, obj); - break; - case T_SortPath: - _outSortPath(str, obj); - break; - case T_IncrementalSortPath: - _outIncrementalSortPath(str, obj); - break; - case T_GroupPath: - _outGroupPath(str, obj); - break; - case T_UpperUniquePath: - _outUpperUniquePath(str, obj); - break; - case T_AggPath: - _outAggPath(str, obj); - break; - case T_GroupingSetsPath: - _outGroupingSetsPath(str, obj); - break; - case T_MinMaxAggPath: - _outMinMaxAggPath(str, obj); - break; - case T_WindowAggPath: - _outWindowAggPath(str, obj); - break; - case T_SetOpPath: - _outSetOpPath(str, obj); - break; - case T_RecursiveUnionPath: - _outRecursiveUnionPath(str, obj); - break; - case T_LockRowsPath: - _outLockRowsPath(str, obj); - break; - case T_ModifyTablePath: - _outModifyTablePath(str, obj); - break; - case T_LimitPath: - _outLimitPath(str, obj); - break; - case T_GatherMergePath: - _outGatherMergePath(str, obj); - break; - case T_NestPath: - _outNestPath(str, obj); - break; - case T_MergePath: - _outMergePath(str, obj); - break; - case T_HashPath: - _outHashPath(str, obj); - break; - case T_PlannerGlobal: - _outPlannerGlobal(str, obj); - break; - case T_PlannerInfo: - _outPlannerInfo(str, obj); - break; - case T_RelOptInfo: - _outRelOptInfo(str, obj); - break; - case T_IndexOptInfo: - _outIndexOptInfo(str, obj); - break; - case T_ForeignKeyOptInfo: - _outForeignKeyOptInfo(str, obj); - break; - case T_EquivalenceClass: - _outEquivalenceClass(str, obj); - break; - case T_EquivalenceMember: - _outEquivalenceMember(str, obj); - break; - case T_PathKey: - _outPathKey(str, obj); - break; - case T_PathTarget: - _outPathTarget(str, obj); - break; - case T_ParamPathInfo: - _outParamPathInfo(str, obj); - break; - case T_RestrictInfo: - _outRestrictInfo(str, obj); - break; - case T_IndexClause: - _outIndexClause(str, obj); - break; - case T_PlaceHolderVar: - _outPlaceHolderVar(str, obj); - break; - case T_SpecialJoinInfo: - _outSpecialJoinInfo(str, obj); - break; - case T_AppendRelInfo: - _outAppendRelInfo(str, obj); - break; - case T_RowIdentityVarInfo: - _outRowIdentityVarInfo(str, obj); - break; - case T_PlaceHolderInfo: - _outPlaceHolderInfo(str, obj); - break; - case T_MinMaxAggInfo: - _outMinMaxAggInfo(str, obj); - break; - case T_PlannerParamItem: - _outPlannerParamItem(str, obj); - break; - case T_RollupData: - _outRollupData(str, obj); - break; - case T_GroupingSetData: - _outGroupingSetData(str, obj); - break; - case T_StatisticExtInfo: - _outStatisticExtInfo(str, obj); - break; - case T_ExtensibleNode: - _outExtensibleNode(str, obj); - break; - case T_CreateStmt: - _outCreateStmt(str, obj); - break; - case T_CreateForeignTableStmt: - _outCreateForeignTableStmt(str, obj); - break; - case T_ImportForeignSchemaStmt: - _outImportForeignSchemaStmt(str, obj); - break; - case T_IndexStmt: - _outIndexStmt(str, obj); - break; - case T_CreateStatsStmt: - _outCreateStatsStmt(str, obj); - break; - case T_AlterStatsStmt: - _outAlterStatsStmt(str, obj); - break; - case T_NotifyStmt: - _outNotifyStmt(str, obj); - break; - case T_DeclareCursorStmt: - _outDeclareCursorStmt(str, obj); - break; - case T_SelectStmt: - _outSelectStmt(str, obj); - break; - case T_ReturnStmt: - _outReturnStmt(str, obj); - break; - case T_PLAssignStmt: - _outPLAssignStmt(str, obj); - break; - case T_ColumnDef: - _outColumnDef(str, obj); - break; - case T_TypeName: - _outTypeName(str, obj); - break; - case T_TypeCast: - _outTypeCast(str, obj); - break; - case T_CollateClause: - _outCollateClause(str, obj); - break; - case T_IndexElem: - _outIndexElem(str, obj); - break; - case T_StatsElem: - _outStatsElem(str, obj); - break; - case T_Query: - _outQuery(str, obj); - break; - case T_WithCheckOption: - _outWithCheckOption(str, obj); - break; - case T_SortGroupClause: - _outSortGroupClause(str, obj); - break; - case T_GroupingSet: - _outGroupingSet(str, obj); - break; - case T_WindowClause: - _outWindowClause(str, obj); - break; - case T_RowMarkClause: - _outRowMarkClause(str, obj); - break; - case T_WithClause: - _outWithClause(str, obj); - break; - case T_CTESearchClause: - _outCTESearchClause(str, obj); - break; - case T_CTECycleClause: - _outCTECycleClause(str, obj); - break; - case T_CommonTableExpr: - _outCommonTableExpr(str, obj); - break; - case T_MergeWhenClause: - _outMergeWhenClause(str, obj); - break; - case T_MergeAction: - _outMergeAction(str, obj); - break; - case T_SetOperationStmt: - _outSetOperationStmt(str, obj); - break; - case T_RangeTblEntry: - _outRangeTblEntry(str, obj); - break; - case T_RangeTblFunction: - _outRangeTblFunction(str, obj); - break; - case T_TableSampleClause: - _outTableSampleClause(str, obj); - break; - case T_A_Expr: - _outA_Expr(str, obj); - break; - case T_ColumnRef: - _outColumnRef(str, obj); - break; - case T_ParamRef: - _outParamRef(str, obj); - break; - case T_RawStmt: - _outRawStmt(str, obj); - break; - case T_A_Const: - _outA_Const(str, obj); - break; - case T_A_Star: - _outA_Star(str, obj); - break; - case T_A_Indices: - _outA_Indices(str, obj); - break; - case T_A_Indirection: - _outA_Indirection(str, obj); - break; - case T_A_ArrayExpr: - _outA_ArrayExpr(str, obj); - break; - case T_ResTarget: - _outResTarget(str, obj); - break; - case T_MultiAssignRef: - _outMultiAssignRef(str, obj); - break; - case T_SortBy: - _outSortBy(str, obj); - break; - case T_WindowDef: - _outWindowDef(str, obj); - break; - case T_RangeSubselect: - _outRangeSubselect(str, obj); - break; - case T_RangeFunction: - _outRangeFunction(str, obj); - break; - case T_RangeTableSample: - _outRangeTableSample(str, obj); - break; - case T_RangeTableFunc: - _outRangeTableFunc(str, obj); - break; - case T_RangeTableFuncCol: - _outRangeTableFuncCol(str, obj); - break; - case T_Constraint: - _outConstraint(str, obj); - break; - case T_FuncCall: - _outFuncCall(str, obj); - break; - case T_DefElem: - _outDefElem(str, obj); - break; - case T_TableLikeClause: - _outTableLikeClause(str, obj); - break; - case T_LockingClause: - _outLockingClause(str, obj); - break; - case T_XmlSerialize: - _outXmlSerialize(str, obj); - break; - case T_ForeignKeyCacheInfo: - _outForeignKeyCacheInfo(str, obj); - break; - case T_TriggerTransition: - _outTriggerTransition(str, obj); - break; - case T_PartitionElem: - _outPartitionElem(str, obj); - break; - case T_PartitionSpec: - _outPartitionSpec(str, obj); - break; - case T_PartitionBoundSpec: - _outPartitionBoundSpec(str, obj); - break; - case T_PartitionRangeDatum: - _outPartitionRangeDatum(str, obj); - break; - case T_JsonFormat: - _outJsonFormat(str, obj); - break; - case T_JsonReturning: - _outJsonReturning(str, obj); - break; - case T_JsonValueExpr: - _outJsonValueExpr(str, obj); - break; - case T_JsonConstructorExpr: - _outJsonConstructorExpr(str, obj); - break; - case T_JsonIsPredicate: - _outJsonIsPredicate(str, obj); - break; - case T_JsonBehavior: - _outJsonBehavior(str, obj); - break; - case T_JsonExpr: - _outJsonExpr(str, obj); - break; - case T_JsonCoercion: - _outJsonCoercion(str, obj); - break; - case T_JsonItemCoercions: - _outJsonItemCoercions(str, obj); - break; - case T_JsonTableParent: - _outJsonTableParent(str, obj); - break; - case T_JsonTableSibling: - _outJsonTableSibling(str, obj); - break; -#endif /* OBSOLETE */ default: diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c index 21176cd4c0..67b0f798c1 100644 --- a/src/backend/nodes/readfuncs.c +++ b/src/backend/nodes/readfuncs.c @@ -238,9 +238,12 @@ readBitmapset(void) #include "readfuncs.funcs.c" + /* - * _readQuery + * Support functions for nodes with custom_read_write attribute or + * special_read_write attribute */ + static Query * _readQuery(void) { @@ -291,350 +294,6 @@ _readQuery(void) READ_DONE(); } -#ifdef OBSOLETE -/* - * _readNotifyStmt - */ -static NotifyStmt * -_readNotifyStmt(void) -{ - READ_LOCALS(NotifyStmt); - - READ_STRING_FIELD(conditionname); - READ_STRING_FIELD(payload); - - READ_DONE(); -} - -/* - * _readDeclareCursorStmt - */ -static DeclareCursorStmt * -_readDeclareCursorStmt(void) -{ - READ_LOCALS(DeclareCursorStmt); - - READ_STRING_FIELD(portalname); - READ_INT_FIELD(options); - READ_NODE_FIELD(query); - - READ_DONE(); -} - -/* - * _readWithCheckOption - */ -static WithCheckOption * -_readWithCheckOption(void) -{ - READ_LOCALS(WithCheckOption); - - READ_ENUM_FIELD(kind, WCOKind); - READ_STRING_FIELD(relname); - READ_STRING_FIELD(polname); - READ_NODE_FIELD(qual); - READ_BOOL_FIELD(cascaded); - - READ_DONE(); -} - -/* - * _readSortGroupClause - */ -static SortGroupClause * -_readSortGroupClause(void) -{ - READ_LOCALS(SortGroupClause); - - READ_UINT_FIELD(tleSortGroupRef); - READ_OID_FIELD(eqop); - READ_OID_FIELD(sortop); - READ_BOOL_FIELD(nulls_first); - READ_BOOL_FIELD(hashable); - - READ_DONE(); -} - -/* - * _readGroupingSet - */ -static GroupingSet * -_readGroupingSet(void) -{ - READ_LOCALS(GroupingSet); - - READ_ENUM_FIELD(kind, GroupingSetKind); - READ_NODE_FIELD(content); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readWindowClause - */ -static WindowClause * -_readWindowClause(void) -{ - READ_LOCALS(WindowClause); - - READ_STRING_FIELD(name); - READ_STRING_FIELD(refname); - READ_NODE_FIELD(partitionClause); - READ_NODE_FIELD(orderClause); - READ_INT_FIELD(frameOptions); - READ_NODE_FIELD(startOffset); - READ_NODE_FIELD(endOffset); - READ_NODE_FIELD(runCondition); - READ_OID_FIELD(startInRangeFunc); - READ_OID_FIELD(endInRangeFunc); - READ_OID_FIELD(inRangeColl); - READ_BOOL_FIELD(inRangeAsc); - READ_BOOL_FIELD(inRangeNullsFirst); - READ_UINT_FIELD(winref); - READ_BOOL_FIELD(copiedOrder); - - READ_DONE(); -} - -/* - * _readRowMarkClause - */ -static RowMarkClause * -_readRowMarkClause(void) -{ - READ_LOCALS(RowMarkClause); - - READ_UINT_FIELD(rti); - READ_ENUM_FIELD(strength, LockClauseStrength); - READ_ENUM_FIELD(waitPolicy, LockWaitPolicy); - READ_BOOL_FIELD(pushedDown); - - READ_DONE(); -} - -/* - * _readCTESearchClause - */ -static CTESearchClause * -_readCTESearchClause(void) -{ - READ_LOCALS(CTESearchClause); - - READ_NODE_FIELD(search_col_list); - READ_BOOL_FIELD(search_breadth_first); - READ_STRING_FIELD(search_seq_column); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readCTECycleClause - */ -static CTECycleClause * -_readCTECycleClause(void) -{ - READ_LOCALS(CTECycleClause); - - READ_NODE_FIELD(cycle_col_list); - READ_STRING_FIELD(cycle_mark_column); - READ_NODE_FIELD(cycle_mark_value); - READ_NODE_FIELD(cycle_mark_default); - READ_STRING_FIELD(cycle_path_column); - READ_LOCATION_FIELD(location); - READ_OID_FIELD(cycle_mark_type); - READ_INT_FIELD(cycle_mark_typmod); - READ_OID_FIELD(cycle_mark_collation); - READ_OID_FIELD(cycle_mark_neop); - - READ_DONE(); -} - -/* - * _readCommonTableExpr - */ -static CommonTableExpr * -_readCommonTableExpr(void) -{ - READ_LOCALS(CommonTableExpr); - - READ_STRING_FIELD(ctename); - READ_NODE_FIELD(aliascolnames); - READ_ENUM_FIELD(ctematerialized, CTEMaterialize); - READ_NODE_FIELD(ctequery); - READ_NODE_FIELD(search_clause); - READ_NODE_FIELD(cycle_clause); - READ_LOCATION_FIELD(location); - READ_BOOL_FIELD(cterecursive); - READ_INT_FIELD(cterefcount); - READ_NODE_FIELD(ctecolnames); - READ_NODE_FIELD(ctecoltypes); - READ_NODE_FIELD(ctecoltypmods); - READ_NODE_FIELD(ctecolcollations); - - READ_DONE(); -} - -/* - * _readMergeWhenClause - */ -static MergeWhenClause * -_readMergeWhenClause(void) -{ - READ_LOCALS(MergeWhenClause); - - READ_BOOL_FIELD(matched); - READ_ENUM_FIELD(commandType, CmdType); - READ_ENUM_FIELD(override, OverridingKind); - READ_NODE_FIELD(condition); - READ_NODE_FIELD(targetList); - READ_NODE_FIELD(values); - - READ_DONE(); -} - -/* - * _readMergeAction - */ -static MergeAction * -_readMergeAction(void) -{ - READ_LOCALS(MergeAction); - - READ_BOOL_FIELD(matched); - READ_ENUM_FIELD(commandType, CmdType); - READ_ENUM_FIELD(override, OverridingKind); - READ_NODE_FIELD(qual); - READ_NODE_FIELD(targetList); - READ_NODE_FIELD(updateColnos); - - READ_DONE(); -} - -/* - * _readSetOperationStmt - */ -static SetOperationStmt * -_readSetOperationStmt(void) -{ - READ_LOCALS(SetOperationStmt); - - READ_ENUM_FIELD(op, SetOperation); - READ_BOOL_FIELD(all); - READ_NODE_FIELD(larg); - READ_NODE_FIELD(rarg); - READ_NODE_FIELD(colTypes); - READ_NODE_FIELD(colTypmods); - READ_NODE_FIELD(colCollations); - READ_NODE_FIELD(groupClauses); - - READ_DONE(); -} - - -/* - * Stuff from primnodes.h. - */ - -static Alias * -_readAlias(void) -{ - READ_LOCALS(Alias); - - READ_STRING_FIELD(aliasname); - READ_NODE_FIELD(colnames); - - READ_DONE(); -} - -static RangeVar * -_readRangeVar(void) -{ - READ_LOCALS(RangeVar); - - local_node->catalogname = NULL; /* not currently saved in output format */ - - READ_STRING_FIELD(schemaname); - READ_STRING_FIELD(relname); - READ_BOOL_FIELD(inh); - READ_CHAR_FIELD(relpersistence); - READ_NODE_FIELD(alias); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readTableFunc - */ -static TableFunc * -_readTableFunc(void) -{ - READ_LOCALS(TableFunc); - - READ_ENUM_FIELD(functype, TableFuncType); - READ_NODE_FIELD(ns_uris); - READ_NODE_FIELD(ns_names); - READ_NODE_FIELD(docexpr); - READ_NODE_FIELD(rowexpr); - READ_NODE_FIELD(colnames); - READ_NODE_FIELD(coltypes); - READ_NODE_FIELD(coltypmods); - READ_NODE_FIELD(colcollations); - READ_NODE_FIELD(colexprs); - READ_NODE_FIELD(coldefexprs); - READ_NODE_FIELD(colvalexprs); - READ_BITMAPSET_FIELD(notnulls); - READ_NODE_FIELD(plan); - READ_INT_FIELD(ordinalitycol); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -static IntoClause * -_readIntoClause(void) -{ - READ_LOCALS(IntoClause); - - READ_NODE_FIELD(rel); - READ_NODE_FIELD(colNames); - READ_STRING_FIELD(accessMethod); - READ_NODE_FIELD(options); - READ_ENUM_FIELD(onCommit, OnCommitAction); - READ_STRING_FIELD(tableSpaceName); - READ_NODE_FIELD(viewQuery); - READ_BOOL_FIELD(skipData); - - READ_DONE(); -} - -/* - * _readVar - */ -static Var * -_readVar(void) -{ - READ_LOCALS(Var); - - READ_INT_FIELD(varno); - READ_INT_FIELD(varattno); - READ_OID_FIELD(vartype); - READ_INT_FIELD(vartypmod); - READ_OID_FIELD(varcollid); - READ_UINT_FIELD(varlevelsup); - READ_UINT_FIELD(varnosyn); - READ_INT_FIELD(varattnosyn); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} -#endif /* OBSOLETE */ - -/* - * _readConst - */ static Const * _readConst(void) { @@ -657,237 +316,6 @@ _readConst(void) READ_DONE(); } -#ifdef OBSOLETE -/* - * _readParam - */ -static Param * -_readParam(void) -{ - READ_LOCALS(Param); - - READ_ENUM_FIELD(paramkind, ParamKind); - READ_INT_FIELD(paramid); - READ_OID_FIELD(paramtype); - READ_INT_FIELD(paramtypmod); - READ_OID_FIELD(paramcollid); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readAggref - */ -static Aggref * -_readAggref(void) -{ - READ_LOCALS(Aggref); - - READ_OID_FIELD(aggfnoid); - READ_OID_FIELD(aggtype); - READ_OID_FIELD(aggcollid); - READ_OID_FIELD(inputcollid); - READ_OID_FIELD(aggtranstype); - READ_NODE_FIELD(aggargtypes); - READ_NODE_FIELD(aggdirectargs); - READ_NODE_FIELD(args); - READ_NODE_FIELD(aggorder); - READ_NODE_FIELD(aggdistinct); - READ_NODE_FIELD(aggfilter); - READ_BOOL_FIELD(aggstar); - READ_BOOL_FIELD(aggvariadic); - READ_CHAR_FIELD(aggkind); - READ_UINT_FIELD(agglevelsup); - READ_ENUM_FIELD(aggsplit, AggSplit); - READ_INT_FIELD(aggno); - READ_INT_FIELD(aggtransno); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readGroupingFunc - */ -static GroupingFunc * -_readGroupingFunc(void) -{ - READ_LOCALS(GroupingFunc); - - READ_NODE_FIELD(args); - READ_NODE_FIELD(refs); - READ_NODE_FIELD(cols); - READ_UINT_FIELD(agglevelsup); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readWindowFunc - */ -static WindowFunc * -_readWindowFunc(void) -{ - READ_LOCALS(WindowFunc); - - READ_OID_FIELD(winfnoid); - READ_OID_FIELD(wintype); - READ_OID_FIELD(wincollid); - READ_OID_FIELD(inputcollid); - READ_NODE_FIELD(args); - READ_NODE_FIELD(aggfilter); - READ_UINT_FIELD(winref); - READ_BOOL_FIELD(winstar); - READ_BOOL_FIELD(winagg); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readSubscriptingRef - */ -static SubscriptingRef * -_readSubscriptingRef(void) -{ - READ_LOCALS(SubscriptingRef); - - READ_OID_FIELD(refcontainertype); - READ_OID_FIELD(refelemtype); - READ_OID_FIELD(refrestype); - READ_INT_FIELD(reftypmod); - READ_OID_FIELD(refcollid); - READ_NODE_FIELD(refupperindexpr); - READ_NODE_FIELD(reflowerindexpr); - READ_NODE_FIELD(refexpr); - READ_NODE_FIELD(refassgnexpr); - - READ_DONE(); -} - -/* - * _readFuncExpr - */ -static FuncExpr * -_readFuncExpr(void) -{ - READ_LOCALS(FuncExpr); - - READ_OID_FIELD(funcid); - READ_OID_FIELD(funcresulttype); - READ_BOOL_FIELD(funcretset); - READ_BOOL_FIELD(funcvariadic); - READ_ENUM_FIELD(funcformat, CoercionForm); - READ_OID_FIELD(funccollid); - READ_OID_FIELD(inputcollid); - READ_NODE_FIELD(args); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readNamedArgExpr - */ -static NamedArgExpr * -_readNamedArgExpr(void) -{ - READ_LOCALS(NamedArgExpr); - - READ_NODE_FIELD(arg); - READ_STRING_FIELD(name); - READ_INT_FIELD(argnumber); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readOpExpr - */ -static OpExpr * -_readOpExpr(void) -{ - READ_LOCALS(OpExpr); - - READ_OID_FIELD(opno); - READ_OID_FIELD(opfuncid); - READ_OID_FIELD(opresulttype); - READ_BOOL_FIELD(opretset); - READ_OID_FIELD(opcollid); - READ_OID_FIELD(inputcollid); - READ_NODE_FIELD(args); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readDistinctExpr - */ -static DistinctExpr * -_readDistinctExpr(void) -{ - READ_LOCALS(DistinctExpr); - - READ_OID_FIELD(opno); - READ_OID_FIELD(opfuncid); - READ_OID_FIELD(opresulttype); - READ_BOOL_FIELD(opretset); - READ_OID_FIELD(opcollid); - READ_OID_FIELD(inputcollid); - READ_NODE_FIELD(args); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readNullIfExpr - */ -static NullIfExpr * -_readNullIfExpr(void) -{ - READ_LOCALS(NullIfExpr); - - READ_OID_FIELD(opno); - READ_OID_FIELD(opfuncid); - READ_OID_FIELD(opresulttype); - READ_BOOL_FIELD(opretset); - READ_OID_FIELD(opcollid); - READ_OID_FIELD(inputcollid); - READ_NODE_FIELD(args); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readScalarArrayOpExpr - */ -static ScalarArrayOpExpr * -_readScalarArrayOpExpr(void) -{ - READ_LOCALS(ScalarArrayOpExpr); - - READ_OID_FIELD(opno); - READ_OID_FIELD(opfuncid); - READ_OID_FIELD(hashfuncid); - READ_OID_FIELD(negfuncid); - READ_BOOL_FIELD(useOr); - READ_OID_FIELD(inputcollid); - READ_NODE_FIELD(args); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} -#endif /* OBSOLETE */ - -/* - * _readBoolExpr - */ static BoolExpr * _readBoolExpr(void) { @@ -911,754 +339,6 @@ _readBoolExpr(void) READ_DONE(); } -#ifdef OBSOLETE -/* - * _readSubLink - */ -static SubLink * -_readSubLink(void) -{ - READ_LOCALS(SubLink); - - READ_ENUM_FIELD(subLinkType, SubLinkType); - READ_INT_FIELD(subLinkId); - READ_NODE_FIELD(testexpr); - READ_NODE_FIELD(operName); - READ_NODE_FIELD(subselect); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readSubPlan is not needed since it doesn't appear in stored rules. - */ - -/* - * _readFieldSelect - */ -static FieldSelect * -_readFieldSelect(void) -{ - READ_LOCALS(FieldSelect); - - READ_NODE_FIELD(arg); - READ_INT_FIELD(fieldnum); - READ_OID_FIELD(resulttype); - READ_INT_FIELD(resulttypmod); - READ_OID_FIELD(resultcollid); - - READ_DONE(); -} - -/* - * _readFieldStore - */ -static FieldStore * -_readFieldStore(void) -{ - READ_LOCALS(FieldStore); - - READ_NODE_FIELD(arg); - READ_NODE_FIELD(newvals); - READ_NODE_FIELD(fieldnums); - READ_OID_FIELD(resulttype); - - READ_DONE(); -} - -/* - * _readRelabelType - */ -static RelabelType * -_readRelabelType(void) -{ - READ_LOCALS(RelabelType); - - READ_NODE_FIELD(arg); - READ_OID_FIELD(resulttype); - READ_INT_FIELD(resulttypmod); - READ_OID_FIELD(resultcollid); - READ_ENUM_FIELD(relabelformat, CoercionForm); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readCoerceViaIO - */ -static CoerceViaIO * -_readCoerceViaIO(void) -{ - READ_LOCALS(CoerceViaIO); - - READ_NODE_FIELD(arg); - READ_OID_FIELD(resulttype); - READ_OID_FIELD(resultcollid); - READ_ENUM_FIELD(coerceformat, CoercionForm); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readArrayCoerceExpr - */ -static ArrayCoerceExpr * -_readArrayCoerceExpr(void) -{ - READ_LOCALS(ArrayCoerceExpr); - - READ_NODE_FIELD(arg); - READ_NODE_FIELD(elemexpr); - READ_OID_FIELD(resulttype); - READ_INT_FIELD(resulttypmod); - READ_OID_FIELD(resultcollid); - READ_ENUM_FIELD(coerceformat, CoercionForm); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readConvertRowtypeExpr - */ -static ConvertRowtypeExpr * -_readConvertRowtypeExpr(void) -{ - READ_LOCALS(ConvertRowtypeExpr); - - READ_NODE_FIELD(arg); - READ_OID_FIELD(resulttype); - READ_ENUM_FIELD(convertformat, CoercionForm); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readCollateExpr - */ -static CollateExpr * -_readCollateExpr(void) -{ - READ_LOCALS(CollateExpr); - - READ_NODE_FIELD(arg); - READ_OID_FIELD(collOid); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readCaseExpr - */ -static CaseExpr * -_readCaseExpr(void) -{ - READ_LOCALS(CaseExpr); - - READ_OID_FIELD(casetype); - READ_OID_FIELD(casecollid); - READ_NODE_FIELD(arg); - READ_NODE_FIELD(args); - READ_NODE_FIELD(defresult); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readCaseWhen - */ -static CaseWhen * -_readCaseWhen(void) -{ - READ_LOCALS(CaseWhen); - - READ_NODE_FIELD(expr); - READ_NODE_FIELD(result); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readCaseTestExpr - */ -static CaseTestExpr * -_readCaseTestExpr(void) -{ - READ_LOCALS(CaseTestExpr); - - READ_OID_FIELD(typeId); - READ_INT_FIELD(typeMod); - READ_OID_FIELD(collation); - - READ_DONE(); -} - -/* - * _readArrayExpr - */ -static ArrayExpr * -_readArrayExpr(void) -{ - READ_LOCALS(ArrayExpr); - - READ_OID_FIELD(array_typeid); - READ_OID_FIELD(array_collid); - READ_OID_FIELD(element_typeid); - READ_NODE_FIELD(elements); - READ_BOOL_FIELD(multidims); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readRowExpr - */ -static RowExpr * -_readRowExpr(void) -{ - READ_LOCALS(RowExpr); - - READ_NODE_FIELD(args); - READ_OID_FIELD(row_typeid); - READ_ENUM_FIELD(row_format, CoercionForm); - READ_NODE_FIELD(colnames); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readRowCompareExpr - */ -static RowCompareExpr * -_readRowCompareExpr(void) -{ - READ_LOCALS(RowCompareExpr); - - READ_ENUM_FIELD(rctype, RowCompareType); - READ_NODE_FIELD(opnos); - READ_NODE_FIELD(opfamilies); - READ_NODE_FIELD(inputcollids); - READ_NODE_FIELD(largs); - READ_NODE_FIELD(rargs); - - READ_DONE(); -} - -/* - * _readCoalesceExpr - */ -static CoalesceExpr * -_readCoalesceExpr(void) -{ - READ_LOCALS(CoalesceExpr); - - READ_OID_FIELD(coalescetype); - READ_OID_FIELD(coalescecollid); - READ_NODE_FIELD(args); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readMinMaxExpr - */ -static MinMaxExpr * -_readMinMaxExpr(void) -{ - READ_LOCALS(MinMaxExpr); - - READ_OID_FIELD(minmaxtype); - READ_OID_FIELD(minmaxcollid); - READ_OID_FIELD(inputcollid); - READ_ENUM_FIELD(op, MinMaxOp); - READ_NODE_FIELD(args); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readSQLValueFunction - */ -static SQLValueFunction * -_readSQLValueFunction(void) -{ - READ_LOCALS(SQLValueFunction); - - READ_ENUM_FIELD(op, SQLValueFunctionOp); - READ_OID_FIELD(type); - READ_INT_FIELD(typmod); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readXmlExpr - */ -static XmlExpr * -_readXmlExpr(void) -{ - READ_LOCALS(XmlExpr); - - READ_ENUM_FIELD(op, XmlExprOp); - READ_STRING_FIELD(name); - READ_NODE_FIELD(named_args); - READ_NODE_FIELD(arg_names); - READ_NODE_FIELD(args); - READ_ENUM_FIELD(xmloption, XmlOptionType); - READ_OID_FIELD(type); - READ_INT_FIELD(typmod); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readNullTest - */ -static NullTest * -_readNullTest(void) -{ - READ_LOCALS(NullTest); - - READ_NODE_FIELD(arg); - READ_ENUM_FIELD(nulltesttype, NullTestType); - READ_BOOL_FIELD(argisrow); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readBooleanTest - */ -static BooleanTest * -_readBooleanTest(void) -{ - READ_LOCALS(BooleanTest); - - READ_NODE_FIELD(arg); - READ_ENUM_FIELD(booltesttype, BoolTestType); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readCoerceToDomain - */ -static CoerceToDomain * -_readCoerceToDomain(void) -{ - READ_LOCALS(CoerceToDomain); - - READ_NODE_FIELD(arg); - READ_OID_FIELD(resulttype); - READ_INT_FIELD(resulttypmod); - READ_OID_FIELD(resultcollid); - READ_ENUM_FIELD(coercionformat, CoercionForm); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readCoerceToDomainValue - */ -static CoerceToDomainValue * -_readCoerceToDomainValue(void) -{ - READ_LOCALS(CoerceToDomainValue); - - READ_OID_FIELD(typeId); - READ_INT_FIELD(typeMod); - READ_OID_FIELD(collation); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readSetToDefault - */ -static SetToDefault * -_readSetToDefault(void) -{ - READ_LOCALS(SetToDefault); - - READ_OID_FIELD(typeId); - READ_INT_FIELD(typeMod); - READ_OID_FIELD(collation); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readCurrentOfExpr - */ -static CurrentOfExpr * -_readCurrentOfExpr(void) -{ - READ_LOCALS(CurrentOfExpr); - - READ_UINT_FIELD(cvarno); - READ_STRING_FIELD(cursor_name); - READ_INT_FIELD(cursor_param); - - READ_DONE(); -} - -/* - * _readNextValueExpr - */ -static NextValueExpr * -_readNextValueExpr(void) -{ - READ_LOCALS(NextValueExpr); - - READ_OID_FIELD(seqid); - READ_OID_FIELD(typeId); - - READ_DONE(); -} - -/* - * _readInferenceElem - */ -static InferenceElem * -_readInferenceElem(void) -{ - READ_LOCALS(InferenceElem); - - READ_NODE_FIELD(expr); - READ_OID_FIELD(infercollid); - READ_OID_FIELD(inferopclass); - - READ_DONE(); -} - -/* - * _readTargetEntry - */ -static TargetEntry * -_readTargetEntry(void) -{ - READ_LOCALS(TargetEntry); - - READ_NODE_FIELD(expr); - READ_INT_FIELD(resno); - READ_STRING_FIELD(resname); - READ_UINT_FIELD(ressortgroupref); - READ_OID_FIELD(resorigtbl); - READ_INT_FIELD(resorigcol); - READ_BOOL_FIELD(resjunk); - - READ_DONE(); -} - -/* - * _readRangeTblRef - */ -static RangeTblRef * -_readRangeTblRef(void) -{ - READ_LOCALS(RangeTblRef); - - READ_INT_FIELD(rtindex); - - READ_DONE(); -} - -/* - * _readJoinExpr - */ -static JoinExpr * -_readJoinExpr(void) -{ - READ_LOCALS(JoinExpr); - - READ_ENUM_FIELD(jointype, JoinType); - READ_BOOL_FIELD(isNatural); - READ_NODE_FIELD(larg); - READ_NODE_FIELD(rarg); - READ_NODE_FIELD(usingClause); - READ_NODE_FIELD(join_using_alias); - READ_NODE_FIELD(quals); - READ_NODE_FIELD(alias); - READ_INT_FIELD(rtindex); - - READ_DONE(); -} - -/* - * _readFromExpr - */ -static FromExpr * -_readFromExpr(void) -{ - READ_LOCALS(FromExpr); - - READ_NODE_FIELD(fromlist); - READ_NODE_FIELD(quals); - - READ_DONE(); -} - -/* - * _readOnConflictExpr - */ -static OnConflictExpr * -_readOnConflictExpr(void) -{ - READ_LOCALS(OnConflictExpr); - - READ_ENUM_FIELD(action, OnConflictAction); - READ_NODE_FIELD(arbiterElems); - READ_NODE_FIELD(arbiterWhere); - READ_OID_FIELD(constraint); - READ_NODE_FIELD(onConflictSet); - READ_NODE_FIELD(onConflictWhere); - READ_INT_FIELD(exclRelIndex); - READ_NODE_FIELD(exclRelTlist); - - READ_DONE(); -} - -/* - * _readJsonFormat - */ -static JsonFormat * -_readJsonFormat(void) -{ - READ_LOCALS(JsonFormat); - - READ_ENUM_FIELD(format_type, JsonFormatType); - READ_ENUM_FIELD(encoding, JsonEncoding); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readJsonReturning - */ -static JsonReturning * -_readJsonReturning(void) -{ - READ_LOCALS(JsonReturning); - - READ_NODE_FIELD(format); - READ_OID_FIELD(typid); - READ_INT_FIELD(typmod); - - READ_DONE(); -} - -/* - * _readJsonValueExpr - */ -static JsonValueExpr * -_readJsonValueExpr(void) -{ - READ_LOCALS(JsonValueExpr); - - READ_NODE_FIELD(raw_expr); - READ_NODE_FIELD(formatted_expr); - READ_NODE_FIELD(format); - - READ_DONE(); -} - -/* - * _readJsonConstructorExpr - */ -static JsonConstructorExpr * -_readJsonConstructorExpr(void) -{ - READ_LOCALS(JsonConstructorExpr); - - READ_ENUM_FIELD(type, JsonConstructorType); - READ_NODE_FIELD(args); - READ_NODE_FIELD(func); - READ_NODE_FIELD(coercion); - READ_NODE_FIELD(returning); - READ_BOOL_FIELD(absent_on_null); - READ_BOOL_FIELD(unique); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readJsonBehavior - */ -static JsonBehavior * -_readJsonBehavior(void) -{ - READ_LOCALS(JsonBehavior); - - READ_ENUM_FIELD(btype, JsonBehaviorType); - READ_NODE_FIELD(default_expr); - - READ_DONE(); -} - -/* - * _readJsonExpr - */ -static JsonExpr * -_readJsonExpr(void) -{ - READ_LOCALS(JsonExpr); - - READ_ENUM_FIELD(op, JsonExprOp); - READ_NODE_FIELD(formatted_expr); - READ_NODE_FIELD(result_coercion); - READ_NODE_FIELD(format); - READ_NODE_FIELD(path_spec); - READ_NODE_FIELD(passing_names); - READ_NODE_FIELD(passing_values); - READ_NODE_FIELD(returning); - READ_NODE_FIELD(on_empty); - READ_NODE_FIELD(on_error); - READ_NODE_FIELD(coercions); - READ_ENUM_FIELD(wrapper, JsonWrapper); - READ_BOOL_FIELD(omit_quotes); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -static JsonTableParent * -_readJsonTableParent(void) -{ - READ_LOCALS(JsonTableParent); - - READ_NODE_FIELD(path); - READ_STRING_FIELD(name); - READ_NODE_FIELD(child); - READ_BOOL_FIELD(outerJoin); - READ_INT_FIELD(colMin); - READ_INT_FIELD(colMax); - READ_BOOL_FIELD(errorOnError); - - READ_DONE(); -} - -static JsonTableSibling * -_readJsonTableSibling(void) -{ - READ_LOCALS(JsonTableSibling); - - READ_NODE_FIELD(larg); - READ_NODE_FIELD(rarg); - READ_BOOL_FIELD(cross); - - READ_DONE(); -} - -/* - * _readJsonCoercion - */ -static JsonCoercion * -_readJsonCoercion(void) -{ - READ_LOCALS(JsonCoercion); - - READ_NODE_FIELD(expr); - READ_BOOL_FIELD(via_populate); - READ_BOOL_FIELD(via_io); - READ_OID_FIELD(collation); - - READ_DONE(); -} - -/* - * _readJsonItemCoercions - */ -static JsonItemCoercions * -_readJsonItemCoercions(void) -{ - READ_LOCALS(JsonItemCoercions); - - READ_NODE_FIELD(null); - READ_NODE_FIELD(string); - READ_NODE_FIELD(numeric); - READ_NODE_FIELD(boolean); - READ_NODE_FIELD(date); - READ_NODE_FIELD(time); - READ_NODE_FIELD(timetz); - READ_NODE_FIELD(timestamp); - READ_NODE_FIELD(timestamptz); - READ_NODE_FIELD(composite); - - READ_DONE(); -} - -/* - * _readJsonIsPredicate - */ -static JsonIsPredicate * -_readJsonIsPredicate() -{ - READ_LOCALS(JsonIsPredicate); - - READ_NODE_FIELD(expr); - READ_NODE_FIELD(format); - READ_ENUM_FIELD(item_type, JsonValueType); - READ_BOOL_FIELD(unique_keys); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * Stuff from pathnodes.h. - * - * Mostly we don't need to read planner nodes back in again, but some - * of these also end up in plan trees. - */ - -/* - * _readAppendRelInfo - */ -static AppendRelInfo * -_readAppendRelInfo(void) -{ - READ_LOCALS(AppendRelInfo); - - READ_UINT_FIELD(parent_relid); - READ_UINT_FIELD(child_relid); - READ_OID_FIELD(parent_reltype); - READ_OID_FIELD(child_reltype); - READ_NODE_FIELD(translated_vars); - READ_INT_FIELD(num_child_cols); - READ_ATTRNUMBER_ARRAY(parent_colnos, local_node->num_child_cols); - READ_OID_FIELD(parent_reloid); - - READ_DONE(); -} - -/* - * Stuff from parsenodes.h. - */ -#endif /* OBSOLETE */ - -/* - * _readRangeTblEntry - */ static RangeTblEntry * _readRangeTblEntry(void) { @@ -1750,1114 +430,6 @@ _readRangeTblEntry(void) READ_DONE(); } -#ifdef OBSOLETE -/* - * _readRangeTblFunction - */ -static RangeTblFunction * -_readRangeTblFunction(void) -{ - READ_LOCALS(RangeTblFunction); - - READ_NODE_FIELD(funcexpr); - READ_INT_FIELD(funccolcount); - READ_NODE_FIELD(funccolnames); - READ_NODE_FIELD(funccoltypes); - READ_NODE_FIELD(funccoltypmods); - READ_NODE_FIELD(funccolcollations); - READ_BITMAPSET_FIELD(funcparams); - - READ_DONE(); -} - -/* - * _readTableSampleClause - */ -static TableSampleClause * -_readTableSampleClause(void) -{ - READ_LOCALS(TableSampleClause); - - READ_OID_FIELD(tsmhandler); - READ_NODE_FIELD(args); - READ_NODE_FIELD(repeatable); - - READ_DONE(); -} - -/* - * _readDefElem - */ -static DefElem * -_readDefElem(void) -{ - READ_LOCALS(DefElem); - - READ_STRING_FIELD(defnamespace); - READ_STRING_FIELD(defname); - READ_NODE_FIELD(arg); - READ_ENUM_FIELD(defaction, DefElemAction); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * Stuff from plannodes.h. - */ - -/* - * _readPlannedStmt - */ -static PlannedStmt * -_readPlannedStmt(void) -{ - READ_LOCALS(PlannedStmt); - - READ_ENUM_FIELD(commandType, CmdType); - READ_UINT64_FIELD(queryId); - READ_BOOL_FIELD(hasReturning); - READ_BOOL_FIELD(hasModifyingCTE); - READ_BOOL_FIELD(canSetTag); - READ_BOOL_FIELD(transientPlan); - READ_BOOL_FIELD(dependsOnRole); - READ_BOOL_FIELD(parallelModeNeeded); - READ_INT_FIELD(jitFlags); - READ_NODE_FIELD(planTree); - READ_NODE_FIELD(rtable); - READ_NODE_FIELD(resultRelations); - READ_NODE_FIELD(appendRelations); - READ_NODE_FIELD(subplans); - READ_BITMAPSET_FIELD(rewindPlanIDs); - READ_NODE_FIELD(rowMarks); - READ_NODE_FIELD(relationOids); - READ_NODE_FIELD(invalItems); - READ_NODE_FIELD(paramExecTypes); - READ_NODE_FIELD(utilityStmt); - READ_LOCATION_FIELD(stmt_location); - READ_INT_FIELD(stmt_len); - - READ_DONE(); -} - -/* - * ReadCommonPlan - * Assign the basic stuff of all nodes that inherit from Plan - */ -static void -ReadCommonPlan(Plan *local_node) -{ - READ_TEMP_LOCALS(); - - READ_FLOAT_FIELD(startup_cost); - READ_FLOAT_FIELD(total_cost); - READ_FLOAT_FIELD(plan_rows); - READ_INT_FIELD(plan_width); - READ_BOOL_FIELD(parallel_aware); - READ_BOOL_FIELD(parallel_safe); - READ_BOOL_FIELD(async_capable); - READ_INT_FIELD(plan_node_id); - READ_NODE_FIELD(targetlist); - READ_NODE_FIELD(qual); - READ_NODE_FIELD(lefttree); - READ_NODE_FIELD(righttree); - READ_NODE_FIELD(initPlan); - READ_BITMAPSET_FIELD(extParam); - READ_BITMAPSET_FIELD(allParam); -} - -/* - * _readResult - */ -static Result * -_readResult(void) -{ - READ_LOCALS(Result); - - ReadCommonPlan(&local_node->plan); - - READ_NODE_FIELD(resconstantqual); - - READ_DONE(); -} - -/* - * _readProjectSet - */ -static ProjectSet * -_readProjectSet(void) -{ - READ_LOCALS_NO_FIELDS(ProjectSet); - - ReadCommonPlan(&local_node->plan); - - READ_DONE(); -} - -/* - * _readModifyTable - */ -static ModifyTable * -_readModifyTable(void) -{ - READ_LOCALS(ModifyTable); - - ReadCommonPlan(&local_node->plan); - - READ_ENUM_FIELD(operation, CmdType); - READ_BOOL_FIELD(canSetTag); - READ_UINT_FIELD(nominalRelation); - READ_UINT_FIELD(rootRelation); - READ_BOOL_FIELD(partColsUpdated); - READ_NODE_FIELD(resultRelations); - READ_NODE_FIELD(updateColnosLists); - READ_NODE_FIELD(withCheckOptionLists); - READ_NODE_FIELD(returningLists); - READ_NODE_FIELD(fdwPrivLists); - READ_BITMAPSET_FIELD(fdwDirectModifyPlans); - READ_NODE_FIELD(rowMarks); - READ_INT_FIELD(epqParam); - READ_ENUM_FIELD(onConflictAction, OnConflictAction); - READ_NODE_FIELD(arbiterIndexes); - READ_NODE_FIELD(onConflictSet); - READ_NODE_FIELD(onConflictCols); - READ_NODE_FIELD(onConflictWhere); - READ_UINT_FIELD(exclRelRTI); - READ_NODE_FIELD(exclRelTlist); - READ_NODE_FIELD(mergeActionLists); - - READ_DONE(); -} - -/* - * _readAppend - */ -static Append * -_readAppend(void) -{ - READ_LOCALS(Append); - - ReadCommonPlan(&local_node->plan); - - READ_BITMAPSET_FIELD(apprelids); - READ_NODE_FIELD(appendplans); - READ_INT_FIELD(nasyncplans); - READ_INT_FIELD(first_partial_plan); - READ_NODE_FIELD(part_prune_info); - - READ_DONE(); -} - -/* - * _readMergeAppend - */ -static MergeAppend * -_readMergeAppend(void) -{ - READ_LOCALS(MergeAppend); - - ReadCommonPlan(&local_node->plan); - - READ_BITMAPSET_FIELD(apprelids); - READ_NODE_FIELD(mergeplans); - READ_INT_FIELD(numCols); - READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols); - READ_OID_ARRAY(sortOperators, local_node->numCols); - READ_OID_ARRAY(collations, local_node->numCols); - READ_BOOL_ARRAY(nullsFirst, local_node->numCols); - READ_NODE_FIELD(part_prune_info); - - READ_DONE(); -} - -/* - * _readRecursiveUnion - */ -static RecursiveUnion * -_readRecursiveUnion(void) -{ - READ_LOCALS(RecursiveUnion); - - ReadCommonPlan(&local_node->plan); - - READ_INT_FIELD(wtParam); - READ_INT_FIELD(numCols); - READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols); - READ_OID_ARRAY(dupOperators, local_node->numCols); - READ_OID_ARRAY(dupCollations, local_node->numCols); - READ_LONG_FIELD(numGroups); - - READ_DONE(); -} - -/* - * _readBitmapAnd - */ -static BitmapAnd * -_readBitmapAnd(void) -{ - READ_LOCALS(BitmapAnd); - - ReadCommonPlan(&local_node->plan); - - READ_NODE_FIELD(bitmapplans); - - READ_DONE(); -} - -/* - * _readBitmapOr - */ -static BitmapOr * -_readBitmapOr(void) -{ - READ_LOCALS(BitmapOr); - - ReadCommonPlan(&local_node->plan); - - READ_BOOL_FIELD(isshared); - READ_NODE_FIELD(bitmapplans); - - READ_DONE(); -} - -/* - * ReadCommonScan - * Assign the basic stuff of all nodes that inherit from Scan - */ -static void -ReadCommonScan(Scan *local_node) -{ - READ_TEMP_LOCALS(); - - ReadCommonPlan(&local_node->plan); - - READ_UINT_FIELD(scanrelid); -} - -/* - * _readScan - */ -static Scan * -_readScan(void) -{ - READ_LOCALS_NO_FIELDS(Scan); - - ReadCommonScan(local_node); - - READ_DONE(); -} - -/* - * _readSeqScan - */ -static SeqScan * -_readSeqScan(void) -{ - READ_LOCALS_NO_FIELDS(SeqScan); - - ReadCommonScan(&local_node->scan); - - READ_DONE(); -} - -/* - * _readSampleScan - */ -static SampleScan * -_readSampleScan(void) -{ - READ_LOCALS(SampleScan); - - ReadCommonScan(&local_node->scan); - - READ_NODE_FIELD(tablesample); - - READ_DONE(); -} - -/* - * _readIndexScan - */ -static IndexScan * -_readIndexScan(void) -{ - READ_LOCALS(IndexScan); - - ReadCommonScan(&local_node->scan); - - READ_OID_FIELD(indexid); - READ_NODE_FIELD(indexqual); - READ_NODE_FIELD(indexqualorig); - READ_NODE_FIELD(indexorderby); - READ_NODE_FIELD(indexorderbyorig); - READ_NODE_FIELD(indexorderbyops); - READ_ENUM_FIELD(indexorderdir, ScanDirection); - - READ_DONE(); -} - -/* - * _readIndexOnlyScan - */ -static IndexOnlyScan * -_readIndexOnlyScan(void) -{ - READ_LOCALS(IndexOnlyScan); - - ReadCommonScan(&local_node->scan); - - READ_OID_FIELD(indexid); - READ_NODE_FIELD(indexqual); - READ_NODE_FIELD(recheckqual); - READ_NODE_FIELD(indexorderby); - READ_NODE_FIELD(indextlist); - READ_ENUM_FIELD(indexorderdir, ScanDirection); - - READ_DONE(); -} - -/* - * _readBitmapIndexScan - */ -static BitmapIndexScan * -_readBitmapIndexScan(void) -{ - READ_LOCALS(BitmapIndexScan); - - ReadCommonScan(&local_node->scan); - - READ_OID_FIELD(indexid); - READ_BOOL_FIELD(isshared); - READ_NODE_FIELD(indexqual); - READ_NODE_FIELD(indexqualorig); - - READ_DONE(); -} - -/* - * _readBitmapHeapScan - */ -static BitmapHeapScan * -_readBitmapHeapScan(void) -{ - READ_LOCALS(BitmapHeapScan); - - ReadCommonScan(&local_node->scan); - - READ_NODE_FIELD(bitmapqualorig); - - READ_DONE(); -} - -/* - * _readTidScan - */ -static TidScan * -_readTidScan(void) -{ - READ_LOCALS(TidScan); - - ReadCommonScan(&local_node->scan); - - READ_NODE_FIELD(tidquals); - - READ_DONE(); -} - -/* - * _readTidRangeScan - */ -static TidRangeScan * -_readTidRangeScan(void) -{ - READ_LOCALS(TidRangeScan); - - ReadCommonScan(&local_node->scan); - - READ_NODE_FIELD(tidrangequals); - - READ_DONE(); -} - -/* - * _readSubqueryScan - */ -static SubqueryScan * -_readSubqueryScan(void) -{ - READ_LOCALS(SubqueryScan); - - ReadCommonScan(&local_node->scan); - - READ_NODE_FIELD(subplan); - READ_ENUM_FIELD(scanstatus, SubqueryScanStatus); - - READ_DONE(); -} - -/* - * _readFunctionScan - */ -static FunctionScan * -_readFunctionScan(void) -{ - READ_LOCALS(FunctionScan); - - ReadCommonScan(&local_node->scan); - - READ_NODE_FIELD(functions); - READ_BOOL_FIELD(funcordinality); - - READ_DONE(); -} - -/* - * _readValuesScan - */ -static ValuesScan * -_readValuesScan(void) -{ - READ_LOCALS(ValuesScan); - - ReadCommonScan(&local_node->scan); - - READ_NODE_FIELD(values_lists); - - READ_DONE(); -} - -/* - * _readTableFuncScan - */ -static TableFuncScan * -_readTableFuncScan(void) -{ - READ_LOCALS(TableFuncScan); - - ReadCommonScan(&local_node->scan); - - READ_NODE_FIELD(tablefunc); - - READ_DONE(); -} - -/* - * _readCteScan - */ -static CteScan * -_readCteScan(void) -{ - READ_LOCALS(CteScan); - - ReadCommonScan(&local_node->scan); - - READ_INT_FIELD(ctePlanId); - READ_INT_FIELD(cteParam); - - READ_DONE(); -} - -/* - * _readNamedTuplestoreScan - */ -static NamedTuplestoreScan * -_readNamedTuplestoreScan(void) -{ - READ_LOCALS(NamedTuplestoreScan); - - ReadCommonScan(&local_node->scan); - - READ_STRING_FIELD(enrname); - - READ_DONE(); -} - -/* - * _readWorkTableScan - */ -static WorkTableScan * -_readWorkTableScan(void) -{ - READ_LOCALS(WorkTableScan); - - ReadCommonScan(&local_node->scan); - - READ_INT_FIELD(wtParam); - - READ_DONE(); -} - -/* - * _readForeignScan - */ -static ForeignScan * -_readForeignScan(void) -{ - READ_LOCALS(ForeignScan); - - ReadCommonScan(&local_node->scan); - - READ_ENUM_FIELD(operation, CmdType); - READ_UINT_FIELD(resultRelation); - READ_OID_FIELD(fs_server); - READ_NODE_FIELD(fdw_exprs); - READ_NODE_FIELD(fdw_private); - READ_NODE_FIELD(fdw_scan_tlist); - READ_NODE_FIELD(fdw_recheck_quals); - READ_BITMAPSET_FIELD(fs_relids); - READ_BOOL_FIELD(fsSystemCol); - - READ_DONE(); -} - -/* - * _readCustomScan - */ -static CustomScan * -_readCustomScan(void) -{ - READ_LOCALS(CustomScan); - char *custom_name; - const CustomScanMethods *methods; - - ReadCommonScan(&local_node->scan); - - READ_UINT_FIELD(flags); - READ_NODE_FIELD(custom_plans); - READ_NODE_FIELD(custom_exprs); - READ_NODE_FIELD(custom_private); - READ_NODE_FIELD(custom_scan_tlist); - READ_BITMAPSET_FIELD(custom_relids); - - /* Lookup CustomScanMethods by CustomName */ - token = pg_strtok(&length); /* skip methods: */ - token = pg_strtok(&length); /* CustomName */ - custom_name = nullable_string(token, length); - methods = GetCustomScanMethods(custom_name, false); - local_node->methods = methods; - - READ_DONE(); -} - -/* - * ReadCommonJoin - * Assign the basic stuff of all nodes that inherit from Join - */ -static void -ReadCommonJoin(Join *local_node) -{ - READ_TEMP_LOCALS(); - - ReadCommonPlan(&local_node->plan); - - READ_ENUM_FIELD(jointype, JoinType); - READ_BOOL_FIELD(inner_unique); - READ_NODE_FIELD(joinqual); -} - -/* - * _readNestLoop - */ -static NestLoop * -_readNestLoop(void) -{ - READ_LOCALS(NestLoop); - - ReadCommonJoin(&local_node->join); - - READ_NODE_FIELD(nestParams); - - READ_DONE(); -} - -/* - * _readMergeJoin - */ -static MergeJoin * -_readMergeJoin(void) -{ - int numCols; - - READ_LOCALS(MergeJoin); - - ReadCommonJoin(&local_node->join); - - READ_BOOL_FIELD(skip_mark_restore); - READ_NODE_FIELD(mergeclauses); - - numCols = list_length(local_node->mergeclauses); - - READ_OID_ARRAY(mergeFamilies, numCols); - READ_OID_ARRAY(mergeCollations, numCols); - READ_INT_ARRAY(mergeStrategies, numCols); - READ_BOOL_ARRAY(mergeNullsFirst, numCols); - - READ_DONE(); -} - -/* - * _readHashJoin - */ -static HashJoin * -_readHashJoin(void) -{ - READ_LOCALS(HashJoin); - - ReadCommonJoin(&local_node->join); - - READ_NODE_FIELD(hashclauses); - READ_NODE_FIELD(hashoperators); - READ_NODE_FIELD(hashcollations); - READ_NODE_FIELD(hashkeys); - - READ_DONE(); -} - -/* - * _readMaterial - */ -static Material * -_readMaterial(void) -{ - READ_LOCALS_NO_FIELDS(Material); - - ReadCommonPlan(&local_node->plan); - - READ_DONE(); -} - -/* - * _readMemoize - */ -static Memoize * -_readMemoize(void) -{ - READ_LOCALS(Memoize); - - ReadCommonPlan(&local_node->plan); - - READ_INT_FIELD(numKeys); - READ_OID_ARRAY(hashOperators, local_node->numKeys); - READ_OID_ARRAY(collations, local_node->numKeys); - READ_NODE_FIELD(param_exprs); - READ_BOOL_FIELD(singlerow); - READ_BOOL_FIELD(binary_mode); - READ_UINT_FIELD(est_entries); - READ_BITMAPSET_FIELD(keyparamids); - - READ_DONE(); -} - -/* - * ReadCommonSort - * Assign the basic stuff of all nodes that inherit from Sort - */ -static void -ReadCommonSort(Sort *local_node) -{ - READ_TEMP_LOCALS(); - - ReadCommonPlan(&local_node->plan); - - READ_INT_FIELD(numCols); - READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols); - READ_OID_ARRAY(sortOperators, local_node->numCols); - READ_OID_ARRAY(collations, local_node->numCols); - READ_BOOL_ARRAY(nullsFirst, local_node->numCols); -} - -/* - * _readSort - */ -static Sort * -_readSort(void) -{ - READ_LOCALS_NO_FIELDS(Sort); - - ReadCommonSort(local_node); - - READ_DONE(); -} - -/* - * _readIncrementalSort - */ -static IncrementalSort * -_readIncrementalSort(void) -{ - READ_LOCALS(IncrementalSort); - - ReadCommonSort(&local_node->sort); - - READ_INT_FIELD(nPresortedCols); - - READ_DONE(); -} - -/* - * _readGroup - */ -static Group * -_readGroup(void) -{ - READ_LOCALS(Group); - - ReadCommonPlan(&local_node->plan); - - READ_INT_FIELD(numCols); - READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols); - READ_OID_ARRAY(grpOperators, local_node->numCols); - READ_OID_ARRAY(grpCollations, local_node->numCols); - - READ_DONE(); -} - -/* - * _readAgg - */ -static Agg * -_readAgg(void) -{ - READ_LOCALS(Agg); - - ReadCommonPlan(&local_node->plan); - - READ_ENUM_FIELD(aggstrategy, AggStrategy); - READ_ENUM_FIELD(aggsplit, AggSplit); - READ_INT_FIELD(numCols); - READ_ATTRNUMBER_ARRAY(grpColIdx, local_node->numCols); - READ_OID_ARRAY(grpOperators, local_node->numCols); - READ_OID_ARRAY(grpCollations, local_node->numCols); - READ_LONG_FIELD(numGroups); - READ_UINT64_FIELD(transitionSpace); - READ_BITMAPSET_FIELD(aggParams); - READ_NODE_FIELD(groupingSets); - READ_NODE_FIELD(chain); - - READ_DONE(); -} - -/* - * _readWindowAgg - */ -static WindowAgg * -_readWindowAgg(void) -{ - READ_LOCALS(WindowAgg); - - ReadCommonPlan(&local_node->plan); - - READ_UINT_FIELD(winref); - READ_INT_FIELD(partNumCols); - READ_ATTRNUMBER_ARRAY(partColIdx, local_node->partNumCols); - READ_OID_ARRAY(partOperators, local_node->partNumCols); - READ_OID_ARRAY(partCollations, local_node->partNumCols); - READ_INT_FIELD(ordNumCols); - READ_ATTRNUMBER_ARRAY(ordColIdx, local_node->ordNumCols); - READ_OID_ARRAY(ordOperators, local_node->ordNumCols); - READ_OID_ARRAY(ordCollations, local_node->ordNumCols); - READ_INT_FIELD(frameOptions); - READ_NODE_FIELD(startOffset); - READ_NODE_FIELD(endOffset); - READ_NODE_FIELD(runCondition); - READ_NODE_FIELD(runConditionOrig); - READ_OID_FIELD(startInRangeFunc); - READ_OID_FIELD(endInRangeFunc); - READ_OID_FIELD(inRangeColl); - READ_BOOL_FIELD(inRangeAsc); - READ_BOOL_FIELD(inRangeNullsFirst); - READ_BOOL_FIELD(topWindow); - - READ_DONE(); -} - -/* - * _readUnique - */ -static Unique * -_readUnique(void) -{ - READ_LOCALS(Unique); - - ReadCommonPlan(&local_node->plan); - - READ_INT_FIELD(numCols); - READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->numCols); - READ_OID_ARRAY(uniqOperators, local_node->numCols); - READ_OID_ARRAY(uniqCollations, local_node->numCols); - - READ_DONE(); -} - -/* - * _readGather - */ -static Gather * -_readGather(void) -{ - READ_LOCALS(Gather); - - ReadCommonPlan(&local_node->plan); - - READ_INT_FIELD(num_workers); - READ_INT_FIELD(rescan_param); - READ_BOOL_FIELD(single_copy); - READ_BOOL_FIELD(invisible); - READ_BITMAPSET_FIELD(initParam); - - READ_DONE(); -} - -/* - * _readGatherMerge - */ -static GatherMerge * -_readGatherMerge(void) -{ - READ_LOCALS(GatherMerge); - - ReadCommonPlan(&local_node->plan); - - READ_INT_FIELD(num_workers); - READ_INT_FIELD(rescan_param); - READ_INT_FIELD(numCols); - READ_ATTRNUMBER_ARRAY(sortColIdx, local_node->numCols); - READ_OID_ARRAY(sortOperators, local_node->numCols); - READ_OID_ARRAY(collations, local_node->numCols); - READ_BOOL_ARRAY(nullsFirst, local_node->numCols); - READ_BITMAPSET_FIELD(initParam); - - READ_DONE(); -} - -/* - * _readHash - */ -static Hash * -_readHash(void) -{ - READ_LOCALS(Hash); - - ReadCommonPlan(&local_node->plan); - - READ_NODE_FIELD(hashkeys); - READ_OID_FIELD(skewTable); - READ_INT_FIELD(skewColumn); - READ_BOOL_FIELD(skewInherit); - READ_FLOAT_FIELD(rows_total); - - READ_DONE(); -} - -/* - * _readSetOp - */ -static SetOp * -_readSetOp(void) -{ - READ_LOCALS(SetOp); - - ReadCommonPlan(&local_node->plan); - - READ_ENUM_FIELD(cmd, SetOpCmd); - READ_ENUM_FIELD(strategy, SetOpStrategy); - READ_INT_FIELD(numCols); - READ_ATTRNUMBER_ARRAY(dupColIdx, local_node->numCols); - READ_OID_ARRAY(dupOperators, local_node->numCols); - READ_OID_ARRAY(dupCollations, local_node->numCols); - READ_INT_FIELD(flagColIdx); - READ_INT_FIELD(firstFlag); - READ_LONG_FIELD(numGroups); - - READ_DONE(); -} - -/* - * _readLockRows - */ -static LockRows * -_readLockRows(void) -{ - READ_LOCALS(LockRows); - - ReadCommonPlan(&local_node->plan); - - READ_NODE_FIELD(rowMarks); - READ_INT_FIELD(epqParam); - - READ_DONE(); -} - -/* - * _readLimit - */ -static Limit * -_readLimit(void) -{ - READ_LOCALS(Limit); - - ReadCommonPlan(&local_node->plan); - - READ_NODE_FIELD(limitOffset); - READ_NODE_FIELD(limitCount); - READ_ENUM_FIELD(limitOption, LimitOption); - READ_INT_FIELD(uniqNumCols); - READ_ATTRNUMBER_ARRAY(uniqColIdx, local_node->uniqNumCols); - READ_OID_ARRAY(uniqOperators, local_node->uniqNumCols); - READ_OID_ARRAY(uniqCollations, local_node->uniqNumCols); - - READ_DONE(); -} - -/* - * _readNestLoopParam - */ -static NestLoopParam * -_readNestLoopParam(void) -{ - READ_LOCALS(NestLoopParam); - - READ_INT_FIELD(paramno); - READ_NODE_FIELD(paramval); - - READ_DONE(); -} - -/* - * _readPlanRowMark - */ -static PlanRowMark * -_readPlanRowMark(void) -{ - READ_LOCALS(PlanRowMark); - - READ_UINT_FIELD(rti); - READ_UINT_FIELD(prti); - READ_UINT_FIELD(rowmarkId); - READ_ENUM_FIELD(markType, RowMarkType); - READ_INT_FIELD(allMarkTypes); - READ_ENUM_FIELD(strength, LockClauseStrength); - READ_ENUM_FIELD(waitPolicy, LockWaitPolicy); - READ_BOOL_FIELD(isParent); - - READ_DONE(); -} - -static PartitionPruneInfo * -_readPartitionPruneInfo(void) -{ - READ_LOCALS(PartitionPruneInfo); - - READ_NODE_FIELD(prune_infos); - READ_BITMAPSET_FIELD(other_subplans); - - READ_DONE(); -} - -static PartitionedRelPruneInfo * -_readPartitionedRelPruneInfo(void) -{ - READ_LOCALS(PartitionedRelPruneInfo); - - READ_UINT_FIELD(rtindex); - READ_BITMAPSET_FIELD(present_parts); - READ_INT_FIELD(nparts); - READ_INT_ARRAY(subplan_map, local_node->nparts); - READ_INT_ARRAY(subpart_map, local_node->nparts); - READ_OID_ARRAY(relid_map, local_node->nparts); - READ_NODE_FIELD(initial_pruning_steps); - READ_NODE_FIELD(exec_pruning_steps); - READ_BITMAPSET_FIELD(execparamids); - - READ_DONE(); -} - -static PartitionPruneStepOp * -_readPartitionPruneStepOp(void) -{ - READ_LOCALS(PartitionPruneStepOp); - - READ_INT_FIELD(step.step_id); - READ_INT_FIELD(opstrategy); - READ_NODE_FIELD(exprs); - READ_NODE_FIELD(cmpfns); - READ_BITMAPSET_FIELD(nullkeys); - - READ_DONE(); -} - -static PartitionPruneStepCombine * -_readPartitionPruneStepCombine(void) -{ - READ_LOCALS(PartitionPruneStepCombine); - - READ_INT_FIELD(step.step_id); - READ_ENUM_FIELD(combineOp, PartitionPruneCombineOp); - READ_NODE_FIELD(source_stepids); - - READ_DONE(); -} - -/* - * _readPlanInvalItem - */ -static PlanInvalItem * -_readPlanInvalItem(void) -{ - READ_LOCALS(PlanInvalItem); - - READ_INT_FIELD(cacheId); - READ_UINT_FIELD(hashValue); - - READ_DONE(); -} - -/* - * _readSubPlan - */ -static SubPlan * -_readSubPlan(void) -{ - READ_LOCALS(SubPlan); - - READ_ENUM_FIELD(subLinkType, SubLinkType); - READ_NODE_FIELD(testexpr); - READ_NODE_FIELD(paramIds); - READ_INT_FIELD(plan_id); - READ_STRING_FIELD(plan_name); - READ_OID_FIELD(firstColType); - READ_INT_FIELD(firstColTypmod); - READ_OID_FIELD(firstColCollation); - READ_BOOL_FIELD(useHashTable); - READ_BOOL_FIELD(unknownEqFalse); - READ_BOOL_FIELD(parallel_safe); - READ_NODE_FIELD(setParam); - READ_NODE_FIELD(parParam); - READ_NODE_FIELD(args); - READ_FLOAT_FIELD(startup_cost); - READ_FLOAT_FIELD(per_call_cost); - - READ_DONE(); -} - -/* - * _readAlternativeSubPlan - */ -static AlternativeSubPlan * -_readAlternativeSubPlan(void) -{ - READ_LOCALS(AlternativeSubPlan); - - READ_NODE_FIELD(subplans); - - READ_DONE(); -} -#endif /* OBSOLETE */ - -/* - * _readExtensibleNode - */ static ExtensibleNode * _readExtensibleNode(void) { @@ -2885,42 +457,6 @@ _readExtensibleNode(void) READ_DONE(); } -#ifdef OBSOLETE -/* - * _readPartitionBoundSpec - */ -static PartitionBoundSpec * -_readPartitionBoundSpec(void) -{ - READ_LOCALS(PartitionBoundSpec); - - READ_CHAR_FIELD(strategy); - READ_BOOL_FIELD(is_default); - READ_INT_FIELD(modulus); - READ_INT_FIELD(remainder); - READ_NODE_FIELD(listdatums); - READ_NODE_FIELD(lowerdatums); - READ_NODE_FIELD(upperdatums); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} - -/* - * _readPartitionRangeDatum - */ -static PartitionRangeDatum * -_readPartitionRangeDatum(void) -{ - READ_LOCALS(PartitionRangeDatum); - - READ_ENUM_FIELD(kind, PartitionRangeDatumKind); - READ_NODE_FIELD(value); - READ_LOCATION_FIELD(location); - - READ_DONE(); -} -#endif /* OBSOLETE */ /* * parseNodeString @@ -2948,278 +484,6 @@ parseNodeString(void) if (false) ; #include "readfuncs.switch.c" -#ifdef OBSOLETE - else if (MATCH("QUERY", 5)) - return_value = _readQuery(); - else if (MATCH("WITHCHECKOPTION", 15)) - return_value = _readWithCheckOption(); - else if (MATCH("SORTGROUPCLAUSE", 15)) - return_value = _readSortGroupClause(); - else if (MATCH("GROUPINGSET", 11)) - return_value = _readGroupingSet(); - else if (MATCH("WINDOWCLAUSE", 12)) - return_value = _readWindowClause(); - else if (MATCH("ROWMARKCLAUSE", 13)) - return_value = _readRowMarkClause(); - else if (MATCH("CTESEARCHCLAUSE", 15)) - return_value = _readCTESearchClause(); - else if (MATCH("CTECYCLECLAUSE", 14)) - return_value = _readCTECycleClause(); - else if (MATCH("COMMONTABLEEXPR", 15)) - return_value = _readCommonTableExpr(); - else if (MATCH("MERGEWHENCLAUSE", 15)) - return_value = _readMergeWhenClause(); - else if (MATCH("MERGEACTION", 11)) - return_value = _readMergeAction(); - else if (MATCH("SETOPERATIONSTMT", 16)) - return_value = _readSetOperationStmt(); - else if (MATCH("ALIAS", 5)) - return_value = _readAlias(); - else if (MATCH("RANGEVAR", 8)) - return_value = _readRangeVar(); - else if (MATCH("INTOCLAUSE", 10)) - return_value = _readIntoClause(); - else if (MATCH("TABLEFUNC", 9)) - return_value = _readTableFunc(); - else if (MATCH("VAR", 3)) - return_value = _readVar(); - else if (MATCH("CONST", 5)) - return_value = _readConst(); - else if (MATCH("PARAM", 5)) - return_value = _readParam(); - else if (MATCH("AGGREF", 6)) - return_value = _readAggref(); - else if (MATCH("GROUPINGFUNC", 12)) - return_value = _readGroupingFunc(); - else if (MATCH("WINDOWFUNC", 10)) - return_value = _readWindowFunc(); - else if (MATCH("SUBSCRIPTINGREF", 15)) - return_value = _readSubscriptingRef(); - else if (MATCH("FUNCEXPR", 8)) - return_value = _readFuncExpr(); - else if (MATCH("NAMEDARGEXPR", 12)) - return_value = _readNamedArgExpr(); - else if (MATCH("OPEXPR", 6)) - return_value = _readOpExpr(); - else if (MATCH("DISTINCTEXPR", 12)) - return_value = _readDistinctExpr(); - else if (MATCH("NULLIFEXPR", 10)) - return_value = _readNullIfExpr(); - else if (MATCH("SCALARARRAYOPEXPR", 17)) - return_value = _readScalarArrayOpExpr(); - else if (MATCH("BOOLEXPR", 8)) - return_value = _readBoolExpr(); - else if (MATCH("SUBLINK", 7)) - return_value = _readSubLink(); - else if (MATCH("FIELDSELECT", 11)) - return_value = _readFieldSelect(); - else if (MATCH("FIELDSTORE", 10)) - return_value = _readFieldStore(); - else if (MATCH("RELABELTYPE", 11)) - return_value = _readRelabelType(); - else if (MATCH("COERCEVIAIO", 11)) - return_value = _readCoerceViaIO(); - else if (MATCH("ARRAYCOERCEEXPR", 15)) - return_value = _readArrayCoerceExpr(); - else if (MATCH("CONVERTROWTYPEEXPR", 18)) - return_value = _readConvertRowtypeExpr(); - else if (MATCH("COLLATEEXPR", 11)) - return_value = _readCollateExpr(); - else if (MATCH("CASEEXPR", 8)) - return_value = _readCaseExpr(); - else if (MATCH("CASEWHEN", 8)) - return_value = _readCaseWhen(); - else if (MATCH("CASETESTEXPR", 12)) - return_value = _readCaseTestExpr(); - else if (MATCH("ARRAYEXPR", 9)) - return_value = _readArrayExpr(); - else if (MATCH("ROWEXPR", 7)) - return_value = _readRowExpr(); - else if (MATCH("ROWCOMPAREEXPR", 14)) - return_value = _readRowCompareExpr(); - else if (MATCH("COALESCEEXPR", 12)) - return_value = _readCoalesceExpr(); - else if (MATCH("MINMAXEXPR", 10)) - return_value = _readMinMaxExpr(); - else if (MATCH("SQLVALUEFUNCTION", 16)) - return_value = _readSQLValueFunction(); - else if (MATCH("XMLEXPR", 7)) - return_value = _readXmlExpr(); - else if (MATCH("NULLTEST", 8)) - return_value = _readNullTest(); - else if (MATCH("BOOLEANTEST", 11)) - return_value = _readBooleanTest(); - else if (MATCH("COERCETODOMAIN", 14)) - return_value = _readCoerceToDomain(); - else if (MATCH("COERCETODOMAINVALUE", 19)) - return_value = _readCoerceToDomainValue(); - else if (MATCH("SETTODEFAULT", 12)) - return_value = _readSetToDefault(); - else if (MATCH("CURRENTOFEXPR", 13)) - return_value = _readCurrentOfExpr(); - else if (MATCH("NEXTVALUEEXPR", 13)) - return_value = _readNextValueExpr(); - else if (MATCH("INFERENCEELEM", 13)) - return_value = _readInferenceElem(); - else if (MATCH("TARGETENTRY", 11)) - return_value = _readTargetEntry(); - else if (MATCH("RANGETBLREF", 11)) - return_value = _readRangeTblRef(); - else if (MATCH("JOINEXPR", 8)) - return_value = _readJoinExpr(); - else if (MATCH("FROMEXPR", 8)) - return_value = _readFromExpr(); - else if (MATCH("ONCONFLICTEXPR", 14)) - return_value = _readOnConflictExpr(); - else if (MATCH("APPENDRELINFO", 13)) - return_value = _readAppendRelInfo(); - else if (MATCH("RANGETBLENTRY", 13)) - return_value = _readRangeTblEntry(); - else if (MATCH("RANGETBLFUNCTION", 16)) - return_value = _readRangeTblFunction(); - else if (MATCH("TABLESAMPLECLAUSE", 17)) - return_value = _readTableSampleClause(); - else if (MATCH("NOTIFYSTMT", 10)) - return_value = _readNotifyStmt(); - else if (MATCH("DEFELEM", 7)) - return_value = _readDefElem(); - else if (MATCH("DECLARECURSORSTMT", 17)) - return_value = _readDeclareCursorStmt(); - else if (MATCH("PLANNEDSTMT", 11)) - return_value = _readPlannedStmt(); - else if (MATCH("RESULT", 6)) - return_value = _readResult(); - else if (MATCH("PROJECTSET", 10)) - return_value = _readProjectSet(); - else if (MATCH("MODIFYTABLE", 11)) - return_value = _readModifyTable(); - else if (MATCH("APPEND", 6)) - return_value = _readAppend(); - else if (MATCH("MERGEAPPEND", 11)) - return_value = _readMergeAppend(); - else if (MATCH("RECURSIVEUNION", 14)) - return_value = _readRecursiveUnion(); - else if (MATCH("BITMAPAND", 9)) - return_value = _readBitmapAnd(); - else if (MATCH("BITMAPOR", 8)) - return_value = _readBitmapOr(); - else if (MATCH("SCAN", 4)) - return_value = _readScan(); - else if (MATCH("SEQSCAN", 7)) - return_value = _readSeqScan(); - else if (MATCH("SAMPLESCAN", 10)) - return_value = _readSampleScan(); - else if (MATCH("INDEXSCAN", 9)) - return_value = _readIndexScan(); - else if (MATCH("INDEXONLYSCAN", 13)) - return_value = _readIndexOnlyScan(); - else if (MATCH("BITMAPINDEXSCAN", 15)) - return_value = _readBitmapIndexScan(); - else if (MATCH("BITMAPHEAPSCAN", 14)) - return_value = _readBitmapHeapScan(); - else if (MATCH("TIDSCAN", 7)) - return_value = _readTidScan(); - else if (MATCH("TIDRANGESCAN", 12)) - return_value = _readTidRangeScan(); - else if (MATCH("SUBQUERYSCAN", 12)) - return_value = _readSubqueryScan(); - else if (MATCH("FUNCTIONSCAN", 12)) - return_value = _readFunctionScan(); - else if (MATCH("VALUESSCAN", 10)) - return_value = _readValuesScan(); - else if (MATCH("TABLEFUNCSCAN", 13)) - return_value = _readTableFuncScan(); - else if (MATCH("CTESCAN", 7)) - return_value = _readCteScan(); - else if (MATCH("NAMEDTUPLESTORESCAN", 19)) - return_value = _readNamedTuplestoreScan(); - else if (MATCH("WORKTABLESCAN", 13)) - return_value = _readWorkTableScan(); - else if (MATCH("FOREIGNSCAN", 11)) - return_value = _readForeignScan(); - else if (MATCH("CUSTOMSCAN", 10)) - return_value = _readCustomScan(); - else if (MATCH("NESTLOOP", 8)) - return_value = _readNestLoop(); - else if (MATCH("MERGEJOIN", 9)) - return_value = _readMergeJoin(); - else if (MATCH("HASHJOIN", 8)) - return_value = _readHashJoin(); - else if (MATCH("MATERIAL", 8)) - return_value = _readMaterial(); - else if (MATCH("MEMOIZE", 7)) - return_value = _readMemoize(); - else if (MATCH("SORT", 4)) - return_value = _readSort(); - else if (MATCH("INCREMENTALSORT", 15)) - return_value = _readIncrementalSort(); - else if (MATCH("GROUP", 5)) - return_value = _readGroup(); - else if (MATCH("AGG", 3)) - return_value = _readAgg(); - else if (MATCH("WINDOWAGG", 9)) - return_value = _readWindowAgg(); - else if (MATCH("UNIQUE", 6)) - return_value = _readUnique(); - else if (MATCH("GATHER", 6)) - return_value = _readGather(); - else if (MATCH("GATHERMERGE", 11)) - return_value = _readGatherMerge(); - else if (MATCH("HASH", 4)) - return_value = _readHash(); - else if (MATCH("SETOP", 5)) - return_value = _readSetOp(); - else if (MATCH("LOCKROWS", 8)) - return_value = _readLockRows(); - else if (MATCH("LIMIT", 5)) - return_value = _readLimit(); - else if (MATCH("NESTLOOPPARAM", 13)) - return_value = _readNestLoopParam(); - else if (MATCH("PLANROWMARK", 11)) - return_value = _readPlanRowMark(); - else if (MATCH("PARTITIONPRUNEINFO", 18)) - return_value = _readPartitionPruneInfo(); - else if (MATCH("PARTITIONEDRELPRUNEINFO", 23)) - return_value = _readPartitionedRelPruneInfo(); - else if (MATCH("PARTITIONPRUNESTEPOP", 20)) - return_value = _readPartitionPruneStepOp(); - else if (MATCH("PARTITIONPRUNESTEPCOMBINE", 25)) - return_value = _readPartitionPruneStepCombine(); - else if (MATCH("PLANINVALITEM", 13)) - return_value = _readPlanInvalItem(); - else if (MATCH("SUBPLAN", 7)) - return_value = _readSubPlan(); - else if (MATCH("ALTERNATIVESUBPLAN", 18)) - return_value = _readAlternativeSubPlan(); - else if (MATCH("EXTENSIBLENODE", 14)) - return_value = _readExtensibleNode(); - else if (MATCH("PARTITIONBOUNDSPEC", 18)) - return_value = _readPartitionBoundSpec(); - else if (MATCH("PARTITIONRANGEDATUM", 19)) - return_value = _readPartitionRangeDatum(); - else if (MATCH("JSONFORMAT", 10)) - return_value = _readJsonFormat(); - else if (MATCH("JSONRETURNING", 13)) - return_value = _readJsonReturning(); - else if (MATCH("JSONVALUEEXPR", 13)) - return_value = _readJsonValueExpr(); - else if (MATCH("JSONCONSTRUCTOREXPR", 19)) - return_value = _readJsonConstructorExpr(); - else if (MATCH("JSONISPREDICATE", 15)) - return_value = _readJsonIsPredicate(); - else if (MATCH("JSONBEHAVIOR", 12)) - return_value = _readJsonBehavior(); - else if (MATCH("JSONEXPR", 8)) - return_value = _readJsonExpr(); - else if (MATCH("JSONCOERCION", 12)) - return_value = _readJsonCoercion(); - else if (MATCH("JSONITEMCOERCIONS", 17)) - return_value = _readJsonItemCoercions(); - else if (MATCH("JSONTABLEPARENT", 15)) - return_value = _readJsonTableParent(); - else if (MATCH("JSONTABLESIBLING", 16)) - return_value = _readJsonTableSibling(); -#endif /* OBSOLETE */ else { elog(ERROR, "badly formatted node string \"%.32s\"...", token); diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h index 9999336eb4..adc549002a 100644 --- a/src/include/nodes/nodes.h +++ b/src/include/nodes/nodes.h @@ -28,537 +28,6 @@ typedef enum NodeTag T_Invalid = 0, #include "nodes/nodetags.h" -#ifdef OBSOLETE - - /* - * TAGS FOR EXECUTOR NODES (execnodes.h) - */ - T_IndexInfo, - T_ExprContext, - T_ProjectionInfo, - T_JunkFilter, - T_OnConflictSetState, - T_MergeActionState, - T_ResultRelInfo, - T_EState, - T_TupleTableSlot, - - /* - * TAGS FOR PLAN NODES (plannodes.h) - */ - T_Result, - T_ProjectSet, - T_ModifyTable, - T_Append, - T_MergeAppend, - T_RecursiveUnion, - T_BitmapAnd, - T_BitmapOr, - T_Scan, - T_SeqScan, - T_SampleScan, - T_IndexScan, - T_IndexOnlyScan, - T_BitmapIndexScan, - T_BitmapHeapScan, - T_TidScan, - T_TidRangeScan, - T_SubqueryScan, - T_FunctionScan, - T_ValuesScan, - T_TableFuncScan, - T_CteScan, - T_NamedTuplestoreScan, - T_WorkTableScan, - T_ForeignScan, - T_CustomScan, - T_NestLoop, - T_MergeJoin, - T_HashJoin, - T_Material, - T_Memoize, - T_Sort, - T_IncrementalSort, - T_Group, - T_Agg, - T_WindowAgg, - T_Unique, - T_Gather, - T_GatherMerge, - T_Hash, - T_SetOp, - T_LockRows, - T_Limit, - /* these aren't subclasses of Plan: */ - T_NestLoopParam, - T_PlanRowMark, - T_PartitionPruneInfo, - T_PartitionedRelPruneInfo, - T_PartitionPruneStepOp, - T_PartitionPruneStepCombine, - T_PlanInvalItem, - - /* - * TAGS FOR PLAN STATE NODES (execnodes.h) - * - * These should correspond one-to-one with Plan node types. - */ - T_PlanState, - T_ResultState, - T_ProjectSetState, - T_ModifyTableState, - T_AppendState, - T_MergeAppendState, - T_RecursiveUnionState, - T_BitmapAndState, - T_BitmapOrState, - T_ScanState, - T_SeqScanState, - T_SampleScanState, - T_IndexScanState, - T_IndexOnlyScanState, - T_BitmapIndexScanState, - T_BitmapHeapScanState, - T_TidScanState, - T_TidRangeScanState, - T_SubqueryScanState, - T_FunctionScanState, - T_TableFuncScanState, - T_ValuesScanState, - T_CteScanState, - T_NamedTuplestoreScanState, - T_WorkTableScanState, - T_ForeignScanState, - T_CustomScanState, - T_JoinState, - T_NestLoopState, - T_MergeJoinState, - T_HashJoinState, - T_MaterialState, - T_MemoizeState, - T_SortState, - T_IncrementalSortState, - T_GroupState, - T_AggState, - T_WindowAggState, - T_UniqueState, - T_GatherState, - T_GatherMergeState, - T_HashState, - T_SetOpState, - T_LockRowsState, - T_LimitState, - - /* - * TAGS FOR PRIMITIVE NODES (primnodes.h) - */ - T_Alias, - T_RangeVar, - T_TableFunc, - T_Var, - T_Const, - T_Param, - T_Aggref, - T_GroupingFunc, - T_WindowFunc, - T_SubscriptingRef, - T_FuncExpr, - T_NamedArgExpr, - T_OpExpr, - T_DistinctExpr, - T_NullIfExpr, - T_ScalarArrayOpExpr, - T_BoolExpr, - T_SubLink, - T_SubPlan, - T_AlternativeSubPlan, - T_FieldSelect, - T_FieldStore, - T_RelabelType, - T_CoerceViaIO, - T_ArrayCoerceExpr, - T_ConvertRowtypeExpr, - T_CollateExpr, - T_CaseExpr, - T_CaseWhen, - T_CaseTestExpr, - T_ArrayExpr, - T_RowExpr, - T_RowCompareExpr, - T_CoalesceExpr, - T_MinMaxExpr, - T_SQLValueFunction, - T_XmlExpr, - T_NullTest, - T_BooleanTest, - T_CoerceToDomain, - T_CoerceToDomainValue, - T_SetToDefault, - T_CurrentOfExpr, - T_NextValueExpr, - T_InferenceElem, - T_TargetEntry, - T_RangeTblRef, - T_JoinExpr, - T_FromExpr, - T_OnConflictExpr, - T_IntoClause, - T_JsonFormat, - T_JsonReturning, - T_JsonValueExpr, - T_JsonParseExpr, - T_JsonScalarExpr, - T_JsonSerializeExpr, - T_JsonConstructorExpr, - T_JsonExpr, - T_JsonCoercion, - T_JsonItemCoercions, - T_JsonTableParent, - T_JsonTableSibling, - - /* - * TAGS FOR EXPRESSION STATE NODES (execnodes.h) - */ - T_ExprState, - T_WindowFuncExprState, - T_SetExprState, - T_SubPlanState, - T_DomainConstraintState, - - /* - * TAGS FOR PLANNER NODES (pathnodes.h) - */ - T_PlannerInfo, - T_PlannerGlobal, - T_RelOptInfo, - T_IndexOptInfo, - T_ForeignKeyOptInfo, - T_ParamPathInfo, - T_Path, - T_IndexPath, - T_BitmapHeapPath, - T_BitmapAndPath, - T_BitmapOrPath, - T_TidPath, - T_TidRangePath, - T_SubqueryScanPath, - T_ForeignPath, - T_CustomPath, - T_NestPath, - T_MergePath, - T_HashPath, - T_AppendPath, - T_MergeAppendPath, - T_GroupResultPath, - T_MaterialPath, - T_MemoizePath, - T_UniquePath, - T_GatherPath, - T_GatherMergePath, - T_ProjectionPath, - T_ProjectSetPath, - T_SortPath, - T_IncrementalSortPath, - T_GroupPath, - T_UpperUniquePath, - T_AggPath, - T_GroupingSetsPath, - T_MinMaxAggPath, - T_WindowAggPath, - T_SetOpPath, - T_RecursiveUnionPath, - T_LockRowsPath, - T_ModifyTablePath, - T_LimitPath, - /* these aren't subclasses of Path: */ - T_EquivalenceClass, - T_EquivalenceMember, - T_PathKey, - T_PathKeyInfo, - T_PathTarget, - T_RestrictInfo, - T_IndexClause, - T_PlaceHolderVar, - T_SpecialJoinInfo, - T_AppendRelInfo, - T_RowIdentityVarInfo, - T_PlaceHolderInfo, - T_MinMaxAggInfo, - T_PlannerParamItem, - T_RollupData, - T_GroupingSetData, - T_StatisticExtInfo, - T_MergeAction, - - /* - * TAGS FOR MEMORY NODES (memnodes.h) - */ - T_AllocSetContext, - T_SlabContext, - T_GenerationContext, - - /* - * TAGS FOR VALUE NODES (value.h) - */ - T_Integer, - T_Float, - T_Boolean, - T_String, - T_BitString, - - /* - * TAGS FOR LIST NODES (pg_list.h) - */ - T_List, - T_IntList, - T_OidList, - T_XidList, - - /* - * TAGS FOR EXTENSIBLE NODES (extensible.h) - */ - T_ExtensibleNode, - - /* - * TAGS FOR STATEMENT NODES (mostly in parsenodes.h) - */ - T_RawStmt, - T_Query, - T_PlannedStmt, - T_InsertStmt, - T_DeleteStmt, - T_UpdateStmt, - T_MergeStmt, - T_SelectStmt, - T_ReturnStmt, - T_PLAssignStmt, - T_AlterTableStmt, - T_AlterTableCmd, - T_AlterDomainStmt, - T_SetOperationStmt, - T_GrantStmt, - T_GrantRoleStmt, - T_AlterDefaultPrivilegesStmt, - T_ClosePortalStmt, - T_ClusterStmt, - T_CopyStmt, - T_CreateStmt, - T_DefineStmt, - T_DropStmt, - T_TruncateStmt, - T_CommentStmt, - T_FetchStmt, - T_IndexStmt, - T_CreateFunctionStmt, - T_AlterFunctionStmt, - T_DoStmt, - T_RenameStmt, - T_RuleStmt, - T_NotifyStmt, - T_ListenStmt, - T_UnlistenStmt, - T_TransactionStmt, - T_ViewStmt, - T_LoadStmt, - T_CreateDomainStmt, - T_CreatedbStmt, - T_DropdbStmt, - T_VacuumStmt, - T_ExplainStmt, - T_CreateTableAsStmt, - T_CreateSeqStmt, - T_AlterSeqStmt, - T_VariableSetStmt, - T_VariableShowStmt, - T_DiscardStmt, - T_CreateTrigStmt, - T_CreatePLangStmt, - T_CreateRoleStmt, - T_AlterRoleStmt, - T_DropRoleStmt, - T_LockStmt, - T_ConstraintsSetStmt, - T_ReindexStmt, - T_CheckPointStmt, - T_CreateSchemaStmt, - T_AlterDatabaseStmt, - T_AlterDatabaseRefreshCollStmt, - T_AlterDatabaseSetStmt, - T_AlterRoleSetStmt, - T_CreateConversionStmt, - T_CreateCastStmt, - T_CreateOpClassStmt, - T_CreateOpFamilyStmt, - T_AlterOpFamilyStmt, - T_PrepareStmt, - T_ExecuteStmt, - T_DeallocateStmt, - T_DeclareCursorStmt, - T_CreateTableSpaceStmt, - T_DropTableSpaceStmt, - T_AlterObjectDependsStmt, - T_AlterObjectSchemaStmt, - T_AlterOwnerStmt, - T_AlterOperatorStmt, - T_AlterTypeStmt, - T_DropOwnedStmt, - T_ReassignOwnedStmt, - T_CompositeTypeStmt, - T_CreateEnumStmt, - T_CreateRangeStmt, - T_AlterEnumStmt, - T_AlterTSDictionaryStmt, - T_AlterTSConfigurationStmt, - T_CreateFdwStmt, - T_AlterFdwStmt, - T_CreateForeignServerStmt, - T_AlterForeignServerStmt, - T_CreateUserMappingStmt, - T_AlterUserMappingStmt, - T_DropUserMappingStmt, - T_AlterTableSpaceOptionsStmt, - T_AlterTableMoveAllStmt, - T_SecLabelStmt, - T_CreateForeignTableStmt, - T_ImportForeignSchemaStmt, - T_CreateExtensionStmt, - T_AlterExtensionStmt, - T_AlterExtensionContentsStmt, - T_CreateEventTrigStmt, - T_AlterEventTrigStmt, - T_RefreshMatViewStmt, - T_ReplicaIdentityStmt, - T_AlterSystemStmt, - T_CreatePolicyStmt, - T_AlterPolicyStmt, - T_CreateTransformStmt, - T_CreateAmStmt, - T_CreatePublicationStmt, - T_AlterPublicationStmt, - T_CreateSubscriptionStmt, - T_AlterSubscriptionStmt, - T_DropSubscriptionStmt, - T_CreateStatsStmt, - T_AlterCollationStmt, - T_CallStmt, - T_AlterStatsStmt, - - /* - * TAGS FOR PARSE TREE NODES (parsenodes.h) - */ - T_A_Expr, - T_ColumnRef, - T_ParamRef, - T_A_Const, - T_FuncCall, - T_A_Star, - T_A_Indices, - T_A_Indirection, - T_A_ArrayExpr, - T_ResTarget, - T_MultiAssignRef, - T_TypeCast, - T_CollateClause, - T_SortBy, - T_WindowDef, - T_RangeSubselect, - T_RangeFunction, - T_RangeTableSample, - T_RangeTableFunc, - T_RangeTableFuncCol, - T_TypeName, - T_ColumnDef, - T_IndexElem, - T_StatsElem, - T_Constraint, - T_DefElem, - T_RangeTblEntry, - T_RangeTblFunction, - T_TableSampleClause, - T_WithCheckOption, - T_SortGroupClause, - T_GroupingSet, - T_WindowClause, - T_ObjectWithArgs, - T_AccessPriv, - T_CreateOpClassItem, - T_TableLikeClause, - T_FunctionParameter, - T_LockingClause, - T_RowMarkClause, - T_XmlSerialize, - T_WithClause, - T_InferClause, - T_OnConflictClause, - T_CTESearchClause, - T_CTECycleClause, - T_CommonTableExpr, - T_MergeWhenClause, - T_RoleSpec, - T_TriggerTransition, - T_PartitionElem, - T_PartitionSpec, - T_PartitionBoundSpec, - T_PartitionRangeDatum, - T_PartitionCmd, - T_VacuumRelation, - T_PublicationObjSpec, - T_PublicationTable, - T_JsonObjectConstructor, - T_JsonArrayConstructor, - T_JsonArrayQueryConstructor, - T_JsonAggConstructor, - T_JsonObjectAgg, - T_JsonArrayAgg, - T_JsonFuncExpr, - T_JsonIsPredicate, - T_JsonTable, - T_JsonTableColumn, - T_JsonTablePlan, - T_JsonCommon, - T_JsonArgument, - T_JsonKeyValue, - T_JsonBehavior, - T_JsonOutput, - - /* - * TAGS FOR REPLICATION GRAMMAR PARSE NODES (replnodes.h) - */ - T_IdentifySystemCmd, - T_BaseBackupCmd, - T_CreateReplicationSlotCmd, - T_DropReplicationSlotCmd, - T_ReadReplicationSlotCmd, - T_StartReplicationCmd, - T_TimeLineHistoryCmd, - - /* - * TAGS FOR RANDOM OTHER STUFF - * - * These are objects that aren't part of parse/plan/execute node tree - * structures, but we give them NodeTags anyway for identification - * purposes (usually because they are involved in APIs where we want to - * pass multiple object types through the same pointer). - */ - T_TriggerData, /* in commands/trigger.h */ - T_EventTriggerData, /* in commands/event_trigger.h */ - T_ReturnSetInfo, /* in nodes/execnodes.h */ - T_WindowObjectData, /* private in nodeWindowAgg.c */ - T_TIDBitmap, /* in nodes/tidbitmap.h */ - T_InlineCodeBlock, /* in nodes/parsenodes.h */ - T_FdwRoutine, /* in foreign/fdwapi.h */ - T_IndexAmRoutine, /* in access/amapi.h */ - T_TableAmRoutine, /* in access/tableam.h */ - T_TsmRoutine, /* in access/tsmapi.h */ - T_ForeignKeyCacheInfo, /* in utils/rel.h */ - T_CallContext, /* in nodes/parsenodes.h */ - T_SupportRequestSimplify, /* in nodes/supportnodes.h */ - T_SupportRequestSelectivity, /* in nodes/supportnodes.h */ - T_SupportRequestCost, /* in nodes/supportnodes.h */ - T_SupportRequestRows, /* in nodes/supportnodes.h */ - T_SupportRequestIndexCondition, /* in nodes/supportnodes.h */ - T_SupportRequestWFuncMonotonic /* in nodes/supportnodes.h */ -#endif /* OBSOLETE */ } NodeTag; /*