* 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
#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
+ * Support functions for nodes with custom_copy_equal attribute
*/
-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)
+static Const *
+_copyConst(const Const *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;
-}
+ Const *newnode = makeNode(Const);
-/*
- * _copyBitmapAnd
- */
-static BitmapAnd *
-_copyBitmapAnd(const BitmapAnd *from)
-{
- BitmapAnd *newnode = makeNode(BitmapAnd);
+ COPY_SCALAR_FIELD(consttype);
+ COPY_SCALAR_FIELD(consttypmod);
+ COPY_SCALAR_FIELD(constcollid);
+ COPY_SCALAR_FIELD(constlen);
- /*
- * copy node superclass fields
- */
- CopyPlanFields((const Plan *) from, (Plan *) newnode);
+ if (from->constbyval || from->constisnull)
+ {
+ /*
+ * passed by value so just copy the datum. Also, don't try to copy
+ * struct when value is null!
+ */
+ newnode->constvalue = from->constvalue;
+ }
+ else
+ {
+ /*
+ * passed by reference. We need a palloc'd copy.
+ */
+ newnode->constvalue = datumCopy(from->constvalue,
+ from->constbyval,
+ from->constlen);
+ }
- /*
- * copy remainder of node
- */
- COPY_NODE_FIELD(bitmapplans);
+ COPY_SCALAR_FIELD(constisnull);
+ COPY_SCALAR_FIELD(constbyval);
+ COPY_LOCATION_FIELD(location);
return newnode;
}
-/*
- * _copyBitmapOr
- */
-static BitmapOr *
-_copyBitmapOr(const BitmapOr *from)
+static A_Const *
+_copyA_Const(const A_Const *from)
{
- BitmapOr *newnode = makeNode(BitmapOr);
+ A_Const *newnode = makeNode(A_Const);
- /*
- * copy node superclass fields
- */
- CopyPlanFields((const Plan *) from, (Plan *) newnode);
+ COPY_SCALAR_FIELD(isnull);
+ if (!from->isnull)
+ {
+ /* This part must duplicate other _copy*() functions. */
+ COPY_SCALAR_FIELD(val.node.type);
+ switch (nodeTag(&from->val))
+ {
+ case T_Integer:
+ COPY_SCALAR_FIELD(val.ival.ival);
+ break;
+ case T_Float:
+ COPY_STRING_FIELD(val.fval.fval);
+ break;
+ case T_Boolean:
+ COPY_SCALAR_FIELD(val.boolval.boolval);
+ break;
+ case T_String:
+ COPY_STRING_FIELD(val.sval.sval);
+ break;
+ case T_BitString:
+ COPY_STRING_FIELD(val.bsval.bsval);
+ break;
+ default:
+ elog(ERROR, "unrecognized node type: %d",
+ (int) nodeTag(&from->val));
+ break;
+ }
+ }
- /*
- * copy remainder of node
- */
- COPY_SCALAR_FIELD(isshared);
- COPY_NODE_FIELD(bitmapplans);
+ COPY_LOCATION_FIELD(location);
return newnode;
}
-/*
- * _copyGather
- */
-static Gather *
-_copyGather(const Gather *from)
+static ExtensibleNode *
+_copyExtensibleNode(const ExtensibleNode *from)
{
- Gather *newnode = makeNode(Gather);
+ ExtensibleNode *newnode;
+ const ExtensibleNodeMethods *methods;
- /*
- * copy node superclass fields
- */
- CopyPlanFields((const Plan *) from, (Plan *) newnode);
+ methods = GetExtensibleNodeMethods(from->extnodename, false);
+ newnode = (ExtensibleNode *) newNode(methods->node_size,
+ T_ExtensibleNode);
+ COPY_STRING_FIELD(extnodename);
- /*
- * 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);
+ /* copy the private fields */
+ methods->nodeCopy(newnode, from);
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
+ * copyObjectImpl -- implementation of copyObject(); see nodes/nodes.h
*
- * 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
+ * Create a copy of a Node tree or list. This is a "deep" copy: all
+ * substructure is copied too, recursively.
*/
-static SubqueryScan *
-_copySubqueryScan(const SubqueryScan *from)
+void *
+copyObjectImpl(const void *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);
+ void *retval;
- return newnode;
-}
+ if (from == NULL)
+ return NULL;
-/*
- * _copyFunctionScan
- */
-static FunctionScan *
-_copyFunctionScan(const FunctionScan *from)
-{
- FunctionScan *newnode = makeNode(FunctionScan);
+ /* Guard against stack overflow due to overly complex expressions */
+ check_stack_depth();
- /*
- * copy node superclass fields
- */
- CopyScanFields((const Scan *) from, (Scan *) newnode);
+ switch (nodeTag(from))
+ {
+#include "copyfuncs.switch.c"
- /*
- * 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
- * ****************************************************************
- */
-
-/*
- * _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)
-{
- Const *newnode = makeNode(Const);
-
- COPY_SCALAR_FIELD(consttype);
- COPY_SCALAR_FIELD(consttypmod);
- COPY_SCALAR_FIELD(constcollid);
- COPY_SCALAR_FIELD(constlen);
-
- if (from->constbyval || from->constisnull)
- {
- /*
- * passed by value so just copy the datum. Also, don't try to copy
- * struct when value is null!
- */
- newnode->constvalue = from->constvalue;
- }
- else
- {
- /*
- * passed by reference. We need a palloc'd copy.
- */
- newnode->constvalue = datumCopy(from->constvalue,
- from->constbyval,
- from->constlen);
- }
-
- COPY_SCALAR_FIELD(constisnull);
- COPY_SCALAR_FIELD(constbyval);
- COPY_LOCATION_FIELD(location);
-
- 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)
-{
- A_Const *newnode = makeNode(A_Const);
-
- COPY_SCALAR_FIELD(isnull);
- if (!from->isnull)
- {
- /* This part must duplicate other _copy*() functions. */
- COPY_SCALAR_FIELD(val.node.type);
- switch (nodeTag(&from->val))
- {
- case T_Integer:
- COPY_SCALAR_FIELD(val.ival.ival);
- break;
- case T_Float:
- COPY_STRING_FIELD(val.fval.fval);
- break;
- case T_Boolean:
- COPY_SCALAR_FIELD(val.boolval.boolval);
- break;
- case T_String:
- COPY_STRING_FIELD(val.sval.sval);
- break;
- case T_BitString:
- COPY_STRING_FIELD(val.bsval.bsval);
- break;
- default:
- elog(ERROR, "unrecognized node type: %d",
- (int) nodeTag(&from->val));
- break;
- }
- }
-
- COPY_LOCATION_FIELD(location);
-
- 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)
-{
- ExtensibleNode *newnode;
- const ExtensibleNodeMethods *methods;
-
- methods = GetExtensibleNodeMethods(from->extnodename, false);
- newnode = (ExtensibleNode *) newNode(methods->node_size,
- T_ExtensibleNode);
- COPY_STRING_FIELD(extnodename);
-
- /* copy the private fields */
- methods->nodeCopy(newnode, 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
- *
- * Create a copy of a Node tree or list. This is a "deep" copy: all
- * substructure is copied too, recursively.
- */
-void *
-copyObjectImpl(const void *from)
-{
- void *retval;
-
- if (from == NULL)
- return NULL;
-
- /* Guard against stack overflow due to overly complex expressions */
- check_stack_depth();
-
- 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;
+ case T_List:
+ retval = list_copy_deep(from);
+ break;
/*
* Lists of integers and OIDs don't need to be deep-copied, so we
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 */
* 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.
#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)
{
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)
+_equalExtensibleNode(const ExtensibleNode *a, const ExtensibleNode *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;
-}
+ const ExtensibleNodeMethods *methods;
-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);
+ COMPARE_STRING_FIELD(extnodename);
- return true;
-}
+ /* At this point, we know extnodename is the same for both nodes. */
+ methods = GetExtensibleNodeMethods(a->extnodename, false);
-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);
+ /* compare the private fields */
+ if (!methods->nodeEqual(a, b))
+ return false;
return true;
}
static bool
-_equalOpExpr(const OpExpr *a, const OpExpr *b)
+_equalA_Const(const A_Const *a, const A_Const *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.
+ * Hack for in-line val field. Also val is not valid is isnull is true.
*/
- if (a->opfuncid != b->opfuncid &&
- a->opfuncid != 0 &&
- b->opfuncid != 0)
+ if (!a->isnull && !b->isnull &&
+ !equal(&a->val, &b->val))
return false;
-
- COMPARE_SCALAR_FIELD(opresulttype);
- COMPARE_SCALAR_FIELD(opretset);
- COMPARE_SCALAR_FIELD(opcollid);
- COMPARE_SCALAR_FIELD(inputcollid);
- COMPARE_NODE_FIELD(args);
+ COMPARE_SCALAR_FIELD(isnull);
COMPARE_LOCATION_FIELD(location);
return true;
}
+/*
+ * Lists are handled specially
+ */
static bool
-_equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b)
+_equalList(const List *a, const List *b)
{
- COMPARE_SCALAR_FIELD(opno);
+ const ListCell *item_a;
+ const ListCell *item_b;
/*
- * 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.
+ * Try to reject by simple scalar checks before grovelling through all the
+ * list elements...
*/
- 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);
+ COMPARE_SCALAR_FIELD(type);
+ COMPARE_SCALAR_FIELD(length);
/*
- * 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.
+ * We place the switch outside the loop for the sake of efficiency; this
+ * may not be worth doing...
*/
- 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);
+ switch (a->type)
+ {
+ case T_List:
+ forboth(item_a, a, item_b, b)
+ {
+ if (!equal(lfirst(item_a), lfirst(item_b)))
+ return false;
+ }
+ break;
+ case T_IntList:
+ forboth(item_a, a, item_b, b)
+ {
+ if (lfirst_int(item_a) != lfirst_int(item_b))
+ return false;
+ }
+ break;
+ case T_OidList:
+ forboth(item_a, a, item_b, b)
+ {
+ if (lfirst_oid(item_a) != lfirst_oid(item_b))
+ return false;
+ }
+ break;
+ default:
+ elog(ERROR, "unrecognized list node type: %d",
+ (int) a->type);
+ return false; /* keep compiler quiet */
+ }
/*
- * 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 we got here, we should have run out of elements of both lists
*/
- 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);
+ Assert(item_a == NULL);
+ Assert(item_b == NULL);
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)
+/*
+ * equal
+ * returns whether two nodes are equal
+ */
+bool
+equal(const void *a, const void *b)
{
- COMPARE_NODE_FIELD(subplans);
-
- return true;
-}
+ bool retval;
-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);
+ if (a == b)
+ return true;
- return true;
-}
+ /*
+ * note that a!=b, so only one of them can be NULL
+ */
+ if (a == NULL || b == NULL)
+ return false;
-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);
+ /*
+ * are they the same type of nodes?
+ */
+ if (nodeTag(a) != nodeTag(b))
+ return false;
- return true;
-}
+ /* Guard against stack overflow due to overly complex expressions */
+ check_stack_depth();
-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)
-{
- const ExtensibleNodeMethods *methods;
-
- COMPARE_STRING_FIELD(extnodename);
-
- /* At this point, we know extnodename is the same for both nodes. */
- methods = GetExtensibleNodeMethods(a->extnodename, false);
-
- /* compare the private fields */
- if (!methods->nodeEqual(a, b))
- return false;
-
- 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)
-{
- /*
- * Hack for in-line val field. Also val is not valid is isnull is true.
- */
- if (!a->isnull && !b->isnull &&
- !equal(&a->val, &b->val))
- return false;
- COMPARE_SCALAR_FIELD(isnull);
- COMPARE_LOCATION_FIELD(location);
-
- 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
- */
-
-static bool
-_equalList(const List *a, const List *b)
-{
- const ListCell *item_a;
- const ListCell *item_b;
-
- /*
- * Try to reject by simple scalar checks before grovelling through all the
- * list elements...
- */
- COMPARE_SCALAR_FIELD(type);
- COMPARE_SCALAR_FIELD(length);
-
- /*
- * We place the switch outside the loop for the sake of efficiency; this
- * may not be worth doing...
- */
- switch (a->type)
- {
- case T_List:
- forboth(item_a, a, item_b, b)
- {
- if (!equal(lfirst(item_a), lfirst(item_b)))
- return false;
- }
- break;
- case T_IntList:
- forboth(item_a, a, item_b, b)
- {
- if (lfirst_int(item_a) != lfirst_int(item_b))
- return false;
- }
- break;
- case T_OidList:
- forboth(item_a, a, item_b, b)
- {
- if (lfirst_oid(item_a) != lfirst_oid(item_b))
- return false;
- }
- break;
- default:
- elog(ERROR, "unrecognized list node type: %d",
- (int) a->type);
- return false; /* keep compiler quiet */
- }
-
- /*
- * If we got here, we should have run out of elements of both lists
- */
- Assert(item_a == NULL);
- Assert(item_b == NULL);
-
- 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
- * returns whether two nodes are equal
- */
-bool
-equal(const void *a, const void *b)
-{
- bool retval;
-
- if (a == b)
- return true;
-
- /*
- * note that a!=b, so only one of them can be NULL
- */
- if (a == NULL || b == NULL)
- return false;
-
- /*
- * are they the same type of nodes?
- */
- if (nodeTag(a) != nodeTag(b))
- return false;
-
- /* Guard against stack overflow due to overly complex expressions */
- check_stack_depth();
-
- 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 */
+ switch (nodeTag(a))
+ {
+#include "equalfuncs.switch.c"
case T_List:
case T_IntList:
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));
#include "outfuncs.funcs.c"
-#ifdef OBSOLETE
+
/*
- * Stuff from plannodes.h
+ * Support functions for nodes with custom_read_write attribute or
+ * special_read_write attribute
*/
static void
-_outPlannedStmt(StringInfo str, const PlannedStmt *node)
+_outConst(StringInfo str, const Const *node)
{
- WRITE_NODE_TYPE("PLANNEDSTMT");
+ WRITE_NODE_TYPE("CONST");
- 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);
-}
+ WRITE_OID_FIELD(consttype);
+ WRITE_INT_FIELD(consttypmod);
+ WRITE_OID_FIELD(constcollid);
+ WRITE_INT_FIELD(constlen);
+ WRITE_BOOL_FIELD(constbyval);
+ WRITE_BOOL_FIELD(constisnull);
+ WRITE_LOCATION_FIELD(location);
-/*
- * print the basic stuff of all nodes that inherit from Plan
- */
-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);
+ appendStringInfoString(str, " :constvalue ");
+ if (node->constisnull)
+ appendStringInfoString(str, "<>");
+ else
+ outDatum(str, node->constvalue, node->constlen, node->constbyval);
}
-/*
- * print the basic stuff of all nodes that inherit from Scan
- */
static void
-_outScanInfo(StringInfo str, const Scan *node)
+_outBoolExpr(StringInfo str, const BoolExpr *node)
{
- _outPlanInfo(str, (const Plan *) node);
+ char *opstr = NULL;
- WRITE_UINT_FIELD(scanrelid);
-}
+ WRITE_NODE_TYPE("BOOLEXPR");
-/*
- * print the basic stuff of all nodes that inherit from Join
- */
-static void
-_outJoinPlanInfo(StringInfo str, const Join *node)
-{
- _outPlanInfo(str, (const Plan *) node);
+ /* do-it-yourself enum representation */
+ switch (node->boolop)
+ {
+ case AND_EXPR:
+ opstr = "and";
+ break;
+ case OR_EXPR:
+ opstr = "or";
+ break;
+ case NOT_EXPR:
+ opstr = "not";
+ break;
+ }
+ appendStringInfoString(str, " :boolop ");
+ outToken(str, opstr);
- WRITE_ENUM_FIELD(jointype, JoinType);
- WRITE_BOOL_FIELD(inner_unique);
- WRITE_NODE_FIELD(joinqual);
+ WRITE_NODE_FIELD(args);
+ WRITE_LOCATION_FIELD(location);
}
static void
-_outResult(StringInfo str, const Result *node)
+_outForeignKeyOptInfo(StringInfo str, const ForeignKeyOptInfo *node)
{
- WRITE_NODE_TYPE("RESULT");
-
- _outPlanInfo(str, (const Plan *) node);
-
- WRITE_NODE_FIELD(resconstantqual);
-}
+ int i;
-static void
-_outProjectSet(StringInfo str, const ProjectSet *node)
-{
- WRITE_NODE_TYPE("PROJECTSET");
+ WRITE_NODE_TYPE("FOREIGNKEYOPTINFO");
- _outPlanInfo(str, (const Plan *) node);
+ WRITE_UINT_FIELD(con_relid);
+ WRITE_UINT_FIELD(ref_relid);
+ WRITE_INT_FIELD(nkeys);
+ WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys);
+ WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys);
+ WRITE_OID_ARRAY(conpfeqop, node->nkeys);
+ WRITE_INT_FIELD(nmatched_ec);
+ WRITE_INT_FIELD(nconst_ec);
+ WRITE_INT_FIELD(nmatched_rcols);
+ WRITE_INT_FIELD(nmatched_ri);
+ /* for compactness, just print the number of matches per column: */
+ appendStringInfoString(str, " :eclass");
+ for (i = 0; i < node->nkeys; i++)
+ appendStringInfo(str, " %d", (node->eclass[i] != NULL));
+ appendStringInfoString(str, " :rinfos");
+ for (i = 0; i < node->nkeys; i++)
+ appendStringInfo(str, " %d", list_length(node->rinfos[i]));
}
static void
-_outModifyTable(StringInfo str, const ModifyTable *node)
+_outEquivalenceClass(StringInfo str, const EquivalenceClass *node)
{
- WRITE_NODE_TYPE("MODIFYTABLE");
+ /*
+ * To simplify reading, we just chase up to the topmost merged EC and
+ * print that, without bothering to show the merge-ees separately.
+ */
+ while (node->ec_merged)
+ node = node->ec_merged;
- _outPlanInfo(str, (const Plan *) node);
+ WRITE_NODE_TYPE("EQUIVALENCECLASS");
- 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);
+ WRITE_NODE_FIELD(ec_opfamilies);
+ WRITE_OID_FIELD(ec_collation);
+ WRITE_NODE_FIELD(ec_members);
+ WRITE_NODE_FIELD(ec_sources);
+ WRITE_NODE_FIELD(ec_derives);
+ WRITE_BITMAPSET_FIELD(ec_relids);
+ WRITE_BOOL_FIELD(ec_has_const);
+ WRITE_BOOL_FIELD(ec_has_volatile);
+ WRITE_BOOL_FIELD(ec_below_outer_join);
+ WRITE_BOOL_FIELD(ec_broken);
+ WRITE_UINT_FIELD(ec_sortref);
+ WRITE_UINT_FIELD(ec_min_security);
+ WRITE_UINT_FIELD(ec_max_security);
}
static void
-_outAppend(StringInfo str, const Append *node)
+_outExtensibleNode(StringInfo str, const ExtensibleNode *node)
{
- WRITE_NODE_TYPE("APPEND");
-
- _outPlanInfo(str, (const Plan *) node);
+ const ExtensibleNodeMethods *methods;
- WRITE_BITMAPSET_FIELD(apprelids);
- WRITE_NODE_FIELD(appendplans);
- WRITE_INT_FIELD(nasyncplans);
- WRITE_INT_FIELD(first_partial_plan);
- WRITE_NODE_FIELD(part_prune_info);
-}
+ methods = GetExtensibleNodeMethods(node->extnodename, false);
-static void
-_outMergeAppend(StringInfo str, const MergeAppend *node)
-{
- WRITE_NODE_TYPE("MERGEAPPEND");
+ WRITE_NODE_TYPE("EXTENSIBLENODE");
- _outPlanInfo(str, (const Plan *) node);
+ WRITE_STRING_FIELD(extnodename);
- 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);
+ /* serialize the private fields */
+ methods->nodeOut(str, node);
}
static void
-_outRecursiveUnion(StringInfo str, const RecursiveUnion *node)
+_outQuery(StringInfo str, const Query *node)
{
- WRITE_NODE_TYPE("RECURSIVEUNION");
+ WRITE_NODE_TYPE("QUERY");
+
+ WRITE_ENUM_FIELD(commandType, CmdType);
+ WRITE_ENUM_FIELD(querySource, QuerySource);
+ /* we intentionally do not print the queryId field */
+ WRITE_BOOL_FIELD(canSetTag);
- _outPlanInfo(str, (const Plan *) node);
+ /*
+ * Hack to work around missing outfuncs routines for a lot of the
+ * utility-statement node types. (The only one we actually *need* for
+ * rules support is NotifyStmt.) Someday we ought to support 'em all, but
+ * for the meantime do this to avoid getting lots of warnings when running
+ * with debug_print_parse on.
+ */
+ if (node->utilityStmt)
+ {
+ switch (nodeTag(node->utilityStmt))
+ {
+ case T_CreateStmt:
+ case T_IndexStmt:
+ case T_NotifyStmt:
+ case T_DeclareCursorStmt:
+ WRITE_NODE_FIELD(utilityStmt);
+ break;
+ default:
+ appendStringInfoString(str, " :utilityStmt ?");
+ break;
+ }
+ }
+ else
+ appendStringInfoString(str, " :utilityStmt <>");
- 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);
+ WRITE_INT_FIELD(resultRelation);
+ WRITE_BOOL_FIELD(hasAggs);
+ WRITE_BOOL_FIELD(hasWindowFuncs);
+ WRITE_BOOL_FIELD(hasTargetSRFs);
+ WRITE_BOOL_FIELD(hasSubLinks);
+ WRITE_BOOL_FIELD(hasDistinctOn);
+ WRITE_BOOL_FIELD(hasRecursive);
+ WRITE_BOOL_FIELD(hasModifyingCTE);
+ WRITE_BOOL_FIELD(hasForUpdate);
+ WRITE_BOOL_FIELD(hasRowSecurity);
+ WRITE_BOOL_FIELD(isReturn);
+ WRITE_NODE_FIELD(cteList);
+ WRITE_NODE_FIELD(rtable);
+ WRITE_NODE_FIELD(jointree);
+ WRITE_NODE_FIELD(targetList);
+ WRITE_ENUM_FIELD(override, OverridingKind);
+ WRITE_NODE_FIELD(onConflict);
+ WRITE_NODE_FIELD(returningList);
+ WRITE_NODE_FIELD(groupClause);
+ WRITE_BOOL_FIELD(groupDistinct);
+ WRITE_NODE_FIELD(groupingSets);
+ WRITE_NODE_FIELD(havingQual);
+ WRITE_NODE_FIELD(windowClause);
+ WRITE_NODE_FIELD(distinctClause);
+ WRITE_NODE_FIELD(sortClause);
+ WRITE_NODE_FIELD(limitOffset);
+ WRITE_NODE_FIELD(limitCount);
+ WRITE_ENUM_FIELD(limitOption, LimitOption);
+ WRITE_NODE_FIELD(rowMarks);
+ WRITE_NODE_FIELD(setOperations);
+ WRITE_NODE_FIELD(constraintDeps);
+ WRITE_NODE_FIELD(withCheckOptions);
+ WRITE_NODE_FIELD(mergeActionList);
+ WRITE_BOOL_FIELD(mergeUseOuterJoin);
+ WRITE_LOCATION_FIELD(stmt_location);
+ WRITE_INT_FIELD(stmt_len);
}
static void
-_outBitmapAnd(StringInfo str, const BitmapAnd *node)
+_outRangeTblEntry(StringInfo str, const RangeTblEntry *node)
{
- WRITE_NODE_TYPE("BITMAPAND");
+ WRITE_NODE_TYPE("RANGETBLENTRY");
+
+ /* put alias + eref first to make dump more legible */
+ WRITE_NODE_FIELD(alias);
+ WRITE_NODE_FIELD(eref);
+ WRITE_ENUM_FIELD(rtekind, RTEKind);
- _outPlanInfo(str, (const Plan *) node);
+ switch (node->rtekind)
+ {
+ case RTE_RELATION:
+ WRITE_OID_FIELD(relid);
+ WRITE_CHAR_FIELD(relkind);
+ WRITE_INT_FIELD(rellockmode);
+ WRITE_NODE_FIELD(tablesample);
+ break;
+ case RTE_SUBQUERY:
+ WRITE_NODE_FIELD(subquery);
+ WRITE_BOOL_FIELD(security_barrier);
+ break;
+ case RTE_JOIN:
+ WRITE_ENUM_FIELD(jointype, JoinType);
+ WRITE_INT_FIELD(joinmergedcols);
+ WRITE_NODE_FIELD(joinaliasvars);
+ WRITE_NODE_FIELD(joinleftcols);
+ WRITE_NODE_FIELD(joinrightcols);
+ WRITE_NODE_FIELD(join_using_alias);
+ break;
+ case RTE_FUNCTION:
+ WRITE_NODE_FIELD(functions);
+ WRITE_BOOL_FIELD(funcordinality);
+ break;
+ case RTE_TABLEFUNC:
+ WRITE_NODE_FIELD(tablefunc);
+ break;
+ case RTE_VALUES:
+ WRITE_NODE_FIELD(values_lists);
+ WRITE_NODE_FIELD(coltypes);
+ WRITE_NODE_FIELD(coltypmods);
+ WRITE_NODE_FIELD(colcollations);
+ break;
+ case RTE_CTE:
+ WRITE_STRING_FIELD(ctename);
+ WRITE_UINT_FIELD(ctelevelsup);
+ WRITE_BOOL_FIELD(self_reference);
+ WRITE_NODE_FIELD(coltypes);
+ WRITE_NODE_FIELD(coltypmods);
+ WRITE_NODE_FIELD(colcollations);
+ break;
+ case RTE_NAMEDTUPLESTORE:
+ WRITE_STRING_FIELD(enrname);
+ WRITE_FLOAT_FIELD(enrtuples, "%.0f");
+ WRITE_OID_FIELD(relid);
+ WRITE_NODE_FIELD(coltypes);
+ WRITE_NODE_FIELD(coltypmods);
+ WRITE_NODE_FIELD(colcollations);
+ break;
+ case RTE_RESULT:
+ /* no extra fields */
+ break;
+ default:
+ elog(ERROR, "unrecognized RTE kind: %d", (int) node->rtekind);
+ break;
+ }
- WRITE_NODE_FIELD(bitmapplans);
+ WRITE_BOOL_FIELD(lateral);
+ WRITE_BOOL_FIELD(inh);
+ WRITE_BOOL_FIELD(inFromCl);
+ WRITE_UINT_FIELD(requiredPerms);
+ WRITE_OID_FIELD(checkAsUser);
+ WRITE_BITMAPSET_FIELD(selectedCols);
+ WRITE_BITMAPSET_FIELD(insertedCols);
+ WRITE_BITMAPSET_FIELD(updatedCols);
+ WRITE_BITMAPSET_FIELD(extraUpdatedCols);
+ WRITE_NODE_FIELD(securityQuals);
}
static void
-_outBitmapOr(StringInfo str, const BitmapOr *node)
+_outA_Expr(StringInfo str, const A_Expr *node)
{
- WRITE_NODE_TYPE("BITMAPOR");
-
- _outPlanInfo(str, (const Plan *) node);
+ WRITE_NODE_TYPE("A_EXPR");
- 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");
+ switch (node->kind)
+ {
+ case AEXPR_OP:
+ appendStringInfoChar(str, ' ');
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_OP_ANY:
+ appendStringInfoChar(str, ' ');
+ WRITE_NODE_FIELD(name);
+ appendStringInfoString(str, " ANY ");
+ break;
+ case AEXPR_OP_ALL:
+ appendStringInfoChar(str, ' ');
+ WRITE_NODE_FIELD(name);
+ appendStringInfoString(str, " ALL ");
+ break;
+ case AEXPR_DISTINCT:
+ appendStringInfoString(str, " DISTINCT ");
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_NOT_DISTINCT:
+ appendStringInfoString(str, " NOT_DISTINCT ");
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_NULLIF:
+ appendStringInfoString(str, " NULLIF ");
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_IN:
+ appendStringInfoString(str, " IN ");
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_LIKE:
+ appendStringInfoString(str, " LIKE ");
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_ILIKE:
+ appendStringInfoString(str, " ILIKE ");
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_SIMILAR:
+ appendStringInfoString(str, " SIMILAR ");
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_BETWEEN:
+ appendStringInfoString(str, " BETWEEN ");
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_NOT_BETWEEN:
+ appendStringInfoString(str, " NOT_BETWEEN ");
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_BETWEEN_SYM:
+ appendStringInfoString(str, " BETWEEN_SYM ");
+ WRITE_NODE_FIELD(name);
+ break;
+ case AEXPR_NOT_BETWEEN_SYM:
+ appendStringInfoString(str, " NOT_BETWEEN_SYM ");
+ WRITE_NODE_FIELD(name);
+ break;
+ default:
+ appendStringInfoString(str, " ??");
+ break;
+ }
- _outScanInfo(str, node);
+ WRITE_NODE_FIELD(lexpr);
+ WRITE_NODE_FIELD(rexpr);
+ WRITE_LOCATION_FIELD(location);
}
static void
-_outSeqScan(StringInfo str, const SeqScan *node)
+_outInteger(StringInfo str, const Integer *node)
{
- WRITE_NODE_TYPE("SEQSCAN");
-
- _outScanInfo(str, (const Scan *) node);
+ appendStringInfo(str, "%d", node->ival);
}
static void
-_outSampleScan(StringInfo str, const SampleScan *node)
+_outFloat(StringInfo str, const Float *node)
{
- WRITE_NODE_TYPE("SAMPLESCAN");
-
- _outScanInfo(str, (const Scan *) node);
-
- WRITE_NODE_FIELD(tablesample);
+ /*
+ * We assume the value is a valid numeric literal and so does not need
+ * quoting.
+ */
+ appendStringInfoString(str, node->fval);
}
static void
-_outIndexScan(StringInfo str, const IndexScan *node)
+_outBoolean(StringInfo str, const Boolean *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);
+ appendStringInfoString(str, node->boolval ? "true" : "false");
}
static void
-_outIndexOnlyScan(StringInfo str, const IndexOnlyScan *node)
+_outString(StringInfo str, const String *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);
+ /*
+ * We use outToken to provide escaping of the string's content, but we
+ * don't want it to do anything with an empty string.
+ */
+ appendStringInfoChar(str, '"');
+ if (node->sval[0] != '\0')
+ outToken(str, node->sval);
+ appendStringInfoChar(str, '"');
}
static void
-_outBitmapIndexScan(StringInfo str, const BitmapIndexScan *node)
+_outBitString(StringInfo str, const BitString *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);
+ /* internal representation already has leading 'b' */
+ appendStringInfoString(str, node->bsval);
}
static void
-_outBitmapHeapScan(StringInfo str, const BitmapHeapScan *node)
+_outA_Const(StringInfo str, const A_Const *node)
{
- WRITE_NODE_TYPE("BITMAPHEAPSCAN");
-
- _outScanInfo(str, (const Scan *) node);
+ WRITE_NODE_TYPE("A_CONST");
- WRITE_NODE_FIELD(bitmapqualorig);
+ if (node->isnull)
+ appendStringInfoString(str, "NULL");
+ else
+ {
+ appendStringInfoString(str, " :val ");
+ outNode(str, &node->val);
+ }
+ WRITE_LOCATION_FIELD(location);
}
static void
-_outTidScan(StringInfo str, const TidScan *node)
+_outConstraint(StringInfo str, const Constraint *node)
{
- WRITE_NODE_TYPE("TIDSCAN");
-
- _outScanInfo(str, (const Scan *) node);
+ WRITE_NODE_TYPE("CONSTRAINT");
- WRITE_NODE_FIELD(tidquals);
-}
+ WRITE_STRING_FIELD(conname);
+ WRITE_BOOL_FIELD(deferrable);
+ WRITE_BOOL_FIELD(initdeferred);
+ WRITE_LOCATION_FIELD(location);
-static void
-_outTidRangeScan(StringInfo str, const TidRangeScan *node)
-{
- WRITE_NODE_TYPE("TIDRANGESCAN");
+ appendStringInfoString(str, " :contype ");
+ switch (node->contype)
+ {
+ case CONSTR_NULL:
+ appendStringInfoString(str, "NULL");
+ break;
- _outScanInfo(str, (const Scan *) node);
+ case CONSTR_NOTNULL:
+ appendStringInfoString(str, "NOT_NULL");
+ break;
- WRITE_NODE_FIELD(tidrangequals);
-}
+ case CONSTR_DEFAULT:
+ appendStringInfoString(str, "DEFAULT");
+ WRITE_NODE_FIELD(raw_expr);
+ WRITE_STRING_FIELD(cooked_expr);
+ break;
-static void
-_outSubqueryScan(StringInfo str, const SubqueryScan *node)
-{
- WRITE_NODE_TYPE("SUBQUERYSCAN");
+ case CONSTR_IDENTITY:
+ appendStringInfoString(str, "IDENTITY");
+ WRITE_NODE_FIELD(raw_expr);
+ WRITE_STRING_FIELD(cooked_expr);
+ WRITE_CHAR_FIELD(generated_when);
+ break;
- _outScanInfo(str, (const Scan *) node);
+ case CONSTR_GENERATED:
+ appendStringInfoString(str, "GENERATED");
+ WRITE_NODE_FIELD(raw_expr);
+ WRITE_STRING_FIELD(cooked_expr);
+ WRITE_CHAR_FIELD(generated_when);
+ break;
- WRITE_NODE_FIELD(subplan);
- WRITE_ENUM_FIELD(scanstatus, SubqueryScanStatus);
-}
+ case CONSTR_CHECK:
+ appendStringInfoString(str, "CHECK");
+ WRITE_BOOL_FIELD(is_no_inherit);
+ WRITE_NODE_FIELD(raw_expr);
+ WRITE_STRING_FIELD(cooked_expr);
+ break;
-static void
-_outFunctionScan(StringInfo str, const FunctionScan *node)
-{
- WRITE_NODE_TYPE("FUNCTIONSCAN");
+ case CONSTR_PRIMARY:
+ appendStringInfoString(str, "PRIMARY_KEY");
+ WRITE_NODE_FIELD(keys);
+ WRITE_NODE_FIELD(including);
+ WRITE_NODE_FIELD(options);
+ WRITE_STRING_FIELD(indexname);
+ WRITE_STRING_FIELD(indexspace);
+ WRITE_BOOL_FIELD(reset_default_tblspc);
+ /* access_method and where_clause not currently used */
+ break;
- _outScanInfo(str, (const Scan *) node);
+ case CONSTR_UNIQUE:
+ appendStringInfoString(str, "UNIQUE");
+ WRITE_BOOL_FIELD(nulls_not_distinct);
+ WRITE_NODE_FIELD(keys);
+ WRITE_NODE_FIELD(including);
+ WRITE_NODE_FIELD(options);
+ WRITE_STRING_FIELD(indexname);
+ WRITE_STRING_FIELD(indexspace);
+ WRITE_BOOL_FIELD(reset_default_tblspc);
+ /* access_method and where_clause not currently used */
+ break;
- WRITE_NODE_FIELD(functions);
- WRITE_BOOL_FIELD(funcordinality);
-}
+ case CONSTR_EXCLUSION:
+ appendStringInfoString(str, "EXCLUSION");
+ WRITE_NODE_FIELD(exclusions);
+ WRITE_NODE_FIELD(including);
+ WRITE_NODE_FIELD(options);
+ WRITE_STRING_FIELD(indexname);
+ WRITE_STRING_FIELD(indexspace);
+ WRITE_BOOL_FIELD(reset_default_tblspc);
+ WRITE_STRING_FIELD(access_method);
+ WRITE_NODE_FIELD(where_clause);
+ break;
-static void
-_outTableFuncScan(StringInfo str, const TableFuncScan *node)
-{
- WRITE_NODE_TYPE("TABLEFUNCSCAN");
+ case CONSTR_FOREIGN:
+ appendStringInfoString(str, "FOREIGN_KEY");
+ WRITE_NODE_FIELD(pktable);
+ WRITE_NODE_FIELD(fk_attrs);
+ WRITE_NODE_FIELD(pk_attrs);
+ WRITE_CHAR_FIELD(fk_matchtype);
+ WRITE_CHAR_FIELD(fk_upd_action);
+ WRITE_CHAR_FIELD(fk_del_action);
+ WRITE_NODE_FIELD(fk_del_set_cols);
+ WRITE_NODE_FIELD(old_conpfeqop);
+ WRITE_OID_FIELD(old_pktable_oid);
+ WRITE_BOOL_FIELD(skip_validation);
+ WRITE_BOOL_FIELD(initially_valid);
+ break;
- _outScanInfo(str, (const Scan *) node);
+ case CONSTR_ATTR_DEFERRABLE:
+ appendStringInfoString(str, "ATTR_DEFERRABLE");
+ break;
- WRITE_NODE_FIELD(tablefunc);
-}
+ case CONSTR_ATTR_NOT_DEFERRABLE:
+ appendStringInfoString(str, "ATTR_NOT_DEFERRABLE");
+ break;
-static void
-_outValuesScan(StringInfo str, const ValuesScan *node)
-{
- WRITE_NODE_TYPE("VALUESSCAN");
+ case CONSTR_ATTR_DEFERRED:
+ appendStringInfoString(str, "ATTR_DEFERRED");
+ break;
- _outScanInfo(str, (const Scan *) node);
+ case CONSTR_ATTR_IMMEDIATE:
+ appendStringInfoString(str, "ATTR_IMMEDIATE");
+ break;
- WRITE_NODE_FIELD(values_lists);
+ default:
+ appendStringInfo(str, "<unrecognized_constraint %d>",
+ (int) node->contype);
+ break;
+ }
}
-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)
+/*
+ * outNode -
+ * converts a Node into ascii string and append it to 'str'
+ */
+void
+outNode(StringInfo str, const void *obj)
{
- 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)
-{
- WRITE_NODE_TYPE("CONST");
-
- WRITE_OID_FIELD(consttype);
- WRITE_INT_FIELD(consttypmod);
- WRITE_OID_FIELD(constcollid);
- WRITE_INT_FIELD(constlen);
- WRITE_BOOL_FIELD(constbyval);
- WRITE_BOOL_FIELD(constisnull);
- WRITE_LOCATION_FIELD(location);
-
- appendStringInfoString(str, " :constvalue ");
- if (node->constisnull)
- appendStringInfoString(str, "<>");
- else
- 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)
-{
- char *opstr = NULL;
-
- WRITE_NODE_TYPE("BOOLEXPR");
-
- /* do-it-yourself enum representation */
- switch (node->boolop)
- {
- case AND_EXPR:
- opstr = "and";
- break;
- case OR_EXPR:
- opstr = "or";
- break;
- case NOT_EXPR:
- opstr = "not";
- break;
- }
- appendStringInfoString(str, " :boolop ");
- outToken(str, opstr);
-
- WRITE_NODE_FIELD(args);
- 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)
-{
- int i;
-
- WRITE_NODE_TYPE("FOREIGNKEYOPTINFO");
-
- WRITE_UINT_FIELD(con_relid);
- WRITE_UINT_FIELD(ref_relid);
- WRITE_INT_FIELD(nkeys);
- WRITE_ATTRNUMBER_ARRAY(conkey, node->nkeys);
- WRITE_ATTRNUMBER_ARRAY(confkey, node->nkeys);
- WRITE_OID_ARRAY(conpfeqop, node->nkeys);
- WRITE_INT_FIELD(nmatched_ec);
- WRITE_INT_FIELD(nconst_ec);
- WRITE_INT_FIELD(nmatched_rcols);
- WRITE_INT_FIELD(nmatched_ri);
- /* for compactness, just print the number of matches per column: */
- appendStringInfoString(str, " :eclass");
- for (i = 0; i < node->nkeys; i++)
- appendStringInfo(str, " %d", (node->eclass[i] != NULL));
- appendStringInfoString(str, " :rinfos");
- for (i = 0; i < node->nkeys; i++)
- 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)
-{
- /*
- * To simplify reading, we just chase up to the topmost merged EC and
- * print that, without bothering to show the merge-ees separately.
- */
- while (node->ec_merged)
- node = node->ec_merged;
-
- WRITE_NODE_TYPE("EQUIVALENCECLASS");
-
- WRITE_NODE_FIELD(ec_opfamilies);
- WRITE_OID_FIELD(ec_collation);
- WRITE_NODE_FIELD(ec_members);
- WRITE_NODE_FIELD(ec_sources);
- WRITE_NODE_FIELD(ec_derives);
- WRITE_BITMAPSET_FIELD(ec_relids);
- WRITE_BOOL_FIELD(ec_has_const);
- WRITE_BOOL_FIELD(ec_has_volatile);
- WRITE_BOOL_FIELD(ec_below_outer_join);
- WRITE_BOOL_FIELD(ec_broken);
- WRITE_UINT_FIELD(ec_sortref);
- WRITE_UINT_FIELD(ec_min_security);
- 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)
-{
- const ExtensibleNodeMethods *methods;
-
- methods = GetExtensibleNodeMethods(node->extnodename, false);
-
- WRITE_NODE_TYPE("EXTENSIBLENODE");
-
- WRITE_STRING_FIELD(extnodename);
-
- /* serialize the private fields */
- 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)
-{
- WRITE_NODE_TYPE("QUERY");
-
- WRITE_ENUM_FIELD(commandType, CmdType);
- WRITE_ENUM_FIELD(querySource, QuerySource);
- /* we intentionally do not print the queryId field */
- WRITE_BOOL_FIELD(canSetTag);
-
- /*
- * Hack to work around missing outfuncs routines for a lot of the
- * utility-statement node types. (The only one we actually *need* for
- * rules support is NotifyStmt.) Someday we ought to support 'em all, but
- * for the meantime do this to avoid getting lots of warnings when running
- * with debug_print_parse on.
- */
- if (node->utilityStmt)
- {
- switch (nodeTag(node->utilityStmt))
- {
- case T_CreateStmt:
- case T_IndexStmt:
- case T_NotifyStmt:
- case T_DeclareCursorStmt:
- WRITE_NODE_FIELD(utilityStmt);
- break;
- default:
- appendStringInfoString(str, " :utilityStmt ?");
- break;
- }
- }
- else
- appendStringInfoString(str, " :utilityStmt <>");
-
- WRITE_INT_FIELD(resultRelation);
- WRITE_BOOL_FIELD(hasAggs);
- WRITE_BOOL_FIELD(hasWindowFuncs);
- WRITE_BOOL_FIELD(hasTargetSRFs);
- WRITE_BOOL_FIELD(hasSubLinks);
- WRITE_BOOL_FIELD(hasDistinctOn);
- WRITE_BOOL_FIELD(hasRecursive);
- WRITE_BOOL_FIELD(hasModifyingCTE);
- WRITE_BOOL_FIELD(hasForUpdate);
- WRITE_BOOL_FIELD(hasRowSecurity);
- WRITE_BOOL_FIELD(isReturn);
- WRITE_NODE_FIELD(cteList);
- WRITE_NODE_FIELD(rtable);
- WRITE_NODE_FIELD(jointree);
- WRITE_NODE_FIELD(targetList);
- WRITE_ENUM_FIELD(override, OverridingKind);
- WRITE_NODE_FIELD(onConflict);
- WRITE_NODE_FIELD(returningList);
- WRITE_NODE_FIELD(groupClause);
- WRITE_BOOL_FIELD(groupDistinct);
- WRITE_NODE_FIELD(groupingSets);
- WRITE_NODE_FIELD(havingQual);
- WRITE_NODE_FIELD(windowClause);
- WRITE_NODE_FIELD(distinctClause);
- WRITE_NODE_FIELD(sortClause);
- WRITE_NODE_FIELD(limitOffset);
- WRITE_NODE_FIELD(limitCount);
- WRITE_ENUM_FIELD(limitOption, LimitOption);
- WRITE_NODE_FIELD(rowMarks);
- WRITE_NODE_FIELD(setOperations);
- WRITE_NODE_FIELD(constraintDeps);
- WRITE_NODE_FIELD(withCheckOptions);
- WRITE_NODE_FIELD(mergeActionList);
- WRITE_BOOL_FIELD(mergeUseOuterJoin);
- WRITE_LOCATION_FIELD(stmt_location);
- 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)
-{
- WRITE_NODE_TYPE("RANGETBLENTRY");
-
- /* put alias + eref first to make dump more legible */
- WRITE_NODE_FIELD(alias);
- WRITE_NODE_FIELD(eref);
- WRITE_ENUM_FIELD(rtekind, RTEKind);
-
- switch (node->rtekind)
- {
- case RTE_RELATION:
- WRITE_OID_FIELD(relid);
- WRITE_CHAR_FIELD(relkind);
- WRITE_INT_FIELD(rellockmode);
- WRITE_NODE_FIELD(tablesample);
- break;
- case RTE_SUBQUERY:
- WRITE_NODE_FIELD(subquery);
- WRITE_BOOL_FIELD(security_barrier);
- break;
- case RTE_JOIN:
- WRITE_ENUM_FIELD(jointype, JoinType);
- WRITE_INT_FIELD(joinmergedcols);
- WRITE_NODE_FIELD(joinaliasvars);
- WRITE_NODE_FIELD(joinleftcols);
- WRITE_NODE_FIELD(joinrightcols);
- WRITE_NODE_FIELD(join_using_alias);
- break;
- case RTE_FUNCTION:
- WRITE_NODE_FIELD(functions);
- WRITE_BOOL_FIELD(funcordinality);
- break;
- case RTE_TABLEFUNC:
- WRITE_NODE_FIELD(tablefunc);
- break;
- case RTE_VALUES:
- WRITE_NODE_FIELD(values_lists);
- WRITE_NODE_FIELD(coltypes);
- WRITE_NODE_FIELD(coltypmods);
- WRITE_NODE_FIELD(colcollations);
- break;
- case RTE_CTE:
- WRITE_STRING_FIELD(ctename);
- WRITE_UINT_FIELD(ctelevelsup);
- WRITE_BOOL_FIELD(self_reference);
- WRITE_NODE_FIELD(coltypes);
- WRITE_NODE_FIELD(coltypmods);
- WRITE_NODE_FIELD(colcollations);
- break;
- case RTE_NAMEDTUPLESTORE:
- WRITE_STRING_FIELD(enrname);
- WRITE_FLOAT_FIELD(enrtuples, "%.0f");
- WRITE_OID_FIELD(relid);
- WRITE_NODE_FIELD(coltypes);
- WRITE_NODE_FIELD(coltypmods);
- WRITE_NODE_FIELD(colcollations);
- break;
- case RTE_RESULT:
- /* no extra fields */
- break;
- default:
- elog(ERROR, "unrecognized RTE kind: %d", (int) node->rtekind);
- break;
- }
-
- WRITE_BOOL_FIELD(lateral);
- WRITE_BOOL_FIELD(inh);
- WRITE_BOOL_FIELD(inFromCl);
- WRITE_UINT_FIELD(requiredPerms);
- WRITE_OID_FIELD(checkAsUser);
- WRITE_BITMAPSET_FIELD(selectedCols);
- WRITE_BITMAPSET_FIELD(insertedCols);
- WRITE_BITMAPSET_FIELD(updatedCols);
- WRITE_BITMAPSET_FIELD(extraUpdatedCols);
- 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)
-{
- WRITE_NODE_TYPE("A_EXPR");
-
- switch (node->kind)
- {
- case AEXPR_OP:
- appendStringInfoChar(str, ' ');
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_OP_ANY:
- appendStringInfoChar(str, ' ');
- WRITE_NODE_FIELD(name);
- appendStringInfoString(str, " ANY ");
- break;
- case AEXPR_OP_ALL:
- appendStringInfoChar(str, ' ');
- WRITE_NODE_FIELD(name);
- appendStringInfoString(str, " ALL ");
- break;
- case AEXPR_DISTINCT:
- appendStringInfoString(str, " DISTINCT ");
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_NOT_DISTINCT:
- appendStringInfoString(str, " NOT_DISTINCT ");
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_NULLIF:
- appendStringInfoString(str, " NULLIF ");
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_IN:
- appendStringInfoString(str, " IN ");
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_LIKE:
- appendStringInfoString(str, " LIKE ");
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_ILIKE:
- appendStringInfoString(str, " ILIKE ");
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_SIMILAR:
- appendStringInfoString(str, " SIMILAR ");
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_BETWEEN:
- appendStringInfoString(str, " BETWEEN ");
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_NOT_BETWEEN:
- appendStringInfoString(str, " NOT_BETWEEN ");
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_BETWEEN_SYM:
- appendStringInfoString(str, " BETWEEN_SYM ");
- WRITE_NODE_FIELD(name);
- break;
- case AEXPR_NOT_BETWEEN_SYM:
- appendStringInfoString(str, " NOT_BETWEEN_SYM ");
- WRITE_NODE_FIELD(name);
- break;
- default:
- appendStringInfoString(str, " ??");
- break;
- }
-
- WRITE_NODE_FIELD(lexpr);
- WRITE_NODE_FIELD(rexpr);
- WRITE_LOCATION_FIELD(location);
-}
-
-static void
-_outInteger(StringInfo str, const Integer *node)
-{
- appendStringInfo(str, "%d", node->ival);
-}
-
-static void
-_outFloat(StringInfo str, const Float *node)
-{
- /*
- * We assume the value is a valid numeric literal and so does not need
- * quoting.
- */
- appendStringInfoString(str, node->fval);
-}
-
-static void
-_outBoolean(StringInfo str, const Boolean *node)
-{
- appendStringInfoString(str, node->boolval ? "true" : "false");
-}
-
-static void
-_outString(StringInfo str, const String *node)
-{
- /*
- * We use outToken to provide escaping of the string's content, but we
- * don't want it to do anything with an empty string.
- */
- appendStringInfoChar(str, '"');
- if (node->sval[0] != '\0')
- outToken(str, node->sval);
- appendStringInfoChar(str, '"');
-}
-
-static void
-_outBitString(StringInfo str, const BitString *node)
-{
- /* internal representation already has leading 'b' */
- 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)
-{
- WRITE_NODE_TYPE("A_CONST");
-
- if (node->isnull)
- appendStringInfoString(str, "NULL");
- else
- {
- appendStringInfoString(str, " :val ");
- outNode(str, &node->val);
- }
- 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)
-{
- WRITE_NODE_TYPE("CONSTRAINT");
-
- WRITE_STRING_FIELD(conname);
- WRITE_BOOL_FIELD(deferrable);
- WRITE_BOOL_FIELD(initdeferred);
- WRITE_LOCATION_FIELD(location);
-
- appendStringInfoString(str, " :contype ");
- switch (node->contype)
- {
- case CONSTR_NULL:
- appendStringInfoString(str, "NULL");
- break;
-
- case CONSTR_NOTNULL:
- appendStringInfoString(str, "NOT_NULL");
- break;
-
- case CONSTR_DEFAULT:
- appendStringInfoString(str, "DEFAULT");
- WRITE_NODE_FIELD(raw_expr);
- WRITE_STRING_FIELD(cooked_expr);
- break;
-
- case CONSTR_IDENTITY:
- appendStringInfoString(str, "IDENTITY");
- WRITE_NODE_FIELD(raw_expr);
- WRITE_STRING_FIELD(cooked_expr);
- WRITE_CHAR_FIELD(generated_when);
- break;
-
- case CONSTR_GENERATED:
- appendStringInfoString(str, "GENERATED");
- WRITE_NODE_FIELD(raw_expr);
- WRITE_STRING_FIELD(cooked_expr);
- WRITE_CHAR_FIELD(generated_when);
- break;
-
- case CONSTR_CHECK:
- appendStringInfoString(str, "CHECK");
- WRITE_BOOL_FIELD(is_no_inherit);
- WRITE_NODE_FIELD(raw_expr);
- WRITE_STRING_FIELD(cooked_expr);
- break;
-
- case CONSTR_PRIMARY:
- appendStringInfoString(str, "PRIMARY_KEY");
- WRITE_NODE_FIELD(keys);
- WRITE_NODE_FIELD(including);
- WRITE_NODE_FIELD(options);
- WRITE_STRING_FIELD(indexname);
- WRITE_STRING_FIELD(indexspace);
- WRITE_BOOL_FIELD(reset_default_tblspc);
- /* access_method and where_clause not currently used */
- break;
-
- case CONSTR_UNIQUE:
- appendStringInfoString(str, "UNIQUE");
- WRITE_BOOL_FIELD(nulls_not_distinct);
- WRITE_NODE_FIELD(keys);
- WRITE_NODE_FIELD(including);
- WRITE_NODE_FIELD(options);
- WRITE_STRING_FIELD(indexname);
- WRITE_STRING_FIELD(indexspace);
- WRITE_BOOL_FIELD(reset_default_tblspc);
- /* access_method and where_clause not currently used */
- break;
-
- case CONSTR_EXCLUSION:
- appendStringInfoString(str, "EXCLUSION");
- WRITE_NODE_FIELD(exclusions);
- WRITE_NODE_FIELD(including);
- WRITE_NODE_FIELD(options);
- WRITE_STRING_FIELD(indexname);
- WRITE_STRING_FIELD(indexspace);
- WRITE_BOOL_FIELD(reset_default_tblspc);
- WRITE_STRING_FIELD(access_method);
- WRITE_NODE_FIELD(where_clause);
- break;
-
- case CONSTR_FOREIGN:
- appendStringInfoString(str, "FOREIGN_KEY");
- WRITE_NODE_FIELD(pktable);
- WRITE_NODE_FIELD(fk_attrs);
- WRITE_NODE_FIELD(pk_attrs);
- WRITE_CHAR_FIELD(fk_matchtype);
- WRITE_CHAR_FIELD(fk_upd_action);
- WRITE_CHAR_FIELD(fk_del_action);
- WRITE_NODE_FIELD(fk_del_set_cols);
- WRITE_NODE_FIELD(old_conpfeqop);
- WRITE_OID_FIELD(old_pktable_oid);
- WRITE_BOOL_FIELD(skip_validation);
- WRITE_BOOL_FIELD(initially_valid);
- break;
-
- case CONSTR_ATTR_DEFERRABLE:
- appendStringInfoString(str, "ATTR_DEFERRABLE");
- break;
-
- case CONSTR_ATTR_NOT_DEFERRABLE:
- appendStringInfoString(str, "ATTR_NOT_DEFERRABLE");
- break;
-
- case CONSTR_ATTR_DEFERRED:
- appendStringInfoString(str, "ATTR_DEFERRED");
- break;
-
- case CONSTR_ATTR_IMMEDIATE:
- appendStringInfoString(str, "ATTR_IMMEDIATE");
- break;
-
- default:
- appendStringInfo(str, "<unrecognized_constraint %d>",
- (int) node->contype);
- break;
- }
-}
-
-#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 -
- * converts a Node into ascii string and append it to 'str'
- */
-void
-outNode(StringInfo str, const void *obj)
-{
- /* Guard against stack overflow due to overly complex expressions */
- check_stack_depth();
+ /* Guard against stack overflow due to overly complex expressions */
+ check_stack_depth();
if (obj == NULL)
appendStringInfoString(str, "<>");
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:
#include "readfuncs.funcs.c"
+
/*
- * _readQuery
+ * Support functions for nodes with custom_read_write attribute or
+ * special_read_write attribute
*/
+
static Query *
_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)
+static Const *
+_readConst(void)
{
- READ_LOCALS(GroupingSet);
+ READ_LOCALS(Const);
- READ_ENUM_FIELD(kind, GroupingSetKind);
- READ_NODE_FIELD(content);
+ READ_OID_FIELD(consttype);
+ READ_INT_FIELD(consttypmod);
+ READ_OID_FIELD(constcollid);
+ READ_INT_FIELD(constlen);
+ READ_BOOL_FIELD(constbyval);
+ READ_BOOL_FIELD(constisnull);
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);
+ token = pg_strtok(&length); /* skip :constvalue */
+ if (local_node->constisnull)
+ token = pg_strtok(&length); /* skip "<>" */
+ else
+ local_node->constvalue = readDatum(local_node->constbyval);
READ_DONE();
}
-/*
- * _readCTECycleClause
- */
-static CTECycleClause *
-_readCTECycleClause(void)
+static BoolExpr *
+_readBoolExpr(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_LOCALS(BoolExpr);
- READ_DONE();
-}
+ /* do-it-yourself enum representation */
+ token = pg_strtok(&length); /* skip :boolop */
+ token = pg_strtok(&length); /* get field value */
+ if (strncmp(token, "and", 3) == 0)
+ local_node->boolop = AND_EXPR;
+ else if (strncmp(token, "or", 2) == 0)
+ local_node->boolop = OR_EXPR;
+ else if (strncmp(token, "not", 3) == 0)
+ local_node->boolop = NOT_EXPR;
+ else
+ elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
-/*
- * _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_NODE_FIELD(args);
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)
+static RangeTblEntry *
+_readRangeTblEntry(void)
{
- READ_LOCALS(Alias);
-
- READ_STRING_FIELD(aliasname);
- READ_NODE_FIELD(colnames);
+ READ_LOCALS(RangeTblEntry);
- READ_DONE();
-}
+ /* put alias + eref first to make dump more legible */
+ READ_NODE_FIELD(alias);
+ READ_NODE_FIELD(eref);
+ READ_ENUM_FIELD(rtekind, RTEKind);
-static RangeVar *
-_readRangeVar(void)
-{
- READ_LOCALS(RangeVar);
+ switch (local_node->rtekind)
+ {
+ case RTE_RELATION:
+ READ_OID_FIELD(relid);
+ READ_CHAR_FIELD(relkind);
+ READ_INT_FIELD(rellockmode);
+ READ_NODE_FIELD(tablesample);
+ break;
+ case RTE_SUBQUERY:
+ READ_NODE_FIELD(subquery);
+ READ_BOOL_FIELD(security_barrier);
+ break;
+ case RTE_JOIN:
+ READ_ENUM_FIELD(jointype, JoinType);
+ READ_INT_FIELD(joinmergedcols);
+ READ_NODE_FIELD(joinaliasvars);
+ READ_NODE_FIELD(joinleftcols);
+ READ_NODE_FIELD(joinrightcols);
+ READ_NODE_FIELD(join_using_alias);
+ break;
+ case RTE_FUNCTION:
+ READ_NODE_FIELD(functions);
+ READ_BOOL_FIELD(funcordinality);
+ break;
+ case RTE_TABLEFUNC:
+ READ_NODE_FIELD(tablefunc);
+ /* The RTE must have a copy of the column type info, if any */
+ if (local_node->tablefunc)
+ {
+ TableFunc *tf = local_node->tablefunc;
- local_node->catalogname = NULL; /* not currently saved in output format */
+ local_node->coltypes = tf->coltypes;
+ local_node->coltypmods = tf->coltypmods;
+ local_node->colcollations = tf->colcollations;
+ }
+ break;
+ case RTE_VALUES:
+ READ_NODE_FIELD(values_lists);
+ READ_NODE_FIELD(coltypes);
+ READ_NODE_FIELD(coltypmods);
+ READ_NODE_FIELD(colcollations);
+ break;
+ case RTE_CTE:
+ READ_STRING_FIELD(ctename);
+ READ_UINT_FIELD(ctelevelsup);
+ READ_BOOL_FIELD(self_reference);
+ READ_NODE_FIELD(coltypes);
+ READ_NODE_FIELD(coltypmods);
+ READ_NODE_FIELD(colcollations);
+ break;
+ case RTE_NAMEDTUPLESTORE:
+ READ_STRING_FIELD(enrname);
+ READ_FLOAT_FIELD(enrtuples);
+ READ_OID_FIELD(relid);
+ READ_NODE_FIELD(coltypes);
+ READ_NODE_FIELD(coltypmods);
+ READ_NODE_FIELD(colcollations);
+ break;
+ case RTE_RESULT:
+ /* no extra fields */
+ break;
+ default:
+ elog(ERROR, "unrecognized RTE kind: %d",
+ (int) local_node->rtekind);
+ break;
+ }
- READ_STRING_FIELD(schemaname);
- READ_STRING_FIELD(relname);
+ READ_BOOL_FIELD(lateral);
READ_BOOL_FIELD(inh);
- READ_CHAR_FIELD(relpersistence);
- READ_NODE_FIELD(alias);
- READ_LOCATION_FIELD(location);
+ READ_BOOL_FIELD(inFromCl);
+ READ_UINT_FIELD(requiredPerms);
+ READ_OID_FIELD(checkAsUser);
+ READ_BITMAPSET_FIELD(selectedCols);
+ READ_BITMAPSET_FIELD(insertedCols);
+ READ_BITMAPSET_FIELD(updatedCols);
+ READ_BITMAPSET_FIELD(extraUpdatedCols);
+ READ_NODE_FIELD(securityQuals);
READ_DONE();
}
-/*
- * _readTableFunc
- */
-static TableFunc *
-_readTableFunc(void)
+static ExtensibleNode *
+_readExtensibleNode(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);
+ const ExtensibleNodeMethods *methods;
+ ExtensibleNode *local_node;
+ const char *extnodename;
- READ_DONE();
-}
+ READ_TEMP_LOCALS();
-static IntoClause *
-_readIntoClause(void)
-{
- READ_LOCALS(IntoClause);
+ token = pg_strtok(&length); /* skip :extnodename */
+ token = pg_strtok(&length); /* get extnodename */
- 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);
+ extnodename = nullable_string(token, length);
+ if (!extnodename)
+ elog(ERROR, "extnodename has to be supplied");
+ methods = GetExtensibleNodeMethods(extnodename, false);
- READ_DONE();
-}
+ local_node = (ExtensibleNode *) newNode(methods->node_size,
+ T_ExtensibleNode);
+ local_node->extnodename = extnodename;
-/*
- * _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);
+ /* deserialize the private fields */
+ methods->nodeRead(local_node);
READ_DONE();
}
-#endif /* OBSOLETE */
-
-/*
- * _readConst
- */
-static Const *
-_readConst(void)
-{
- READ_LOCALS(Const);
- READ_OID_FIELD(consttype);
- READ_INT_FIELD(consttypmod);
- READ_OID_FIELD(constcollid);
- READ_INT_FIELD(constlen);
- READ_BOOL_FIELD(constbyval);
- READ_BOOL_FIELD(constisnull);
- READ_LOCATION_FIELD(location);
-
- token = pg_strtok(&length); /* skip :constvalue */
- if (local_node->constisnull)
- token = pg_strtok(&length); /* skip "<>" */
- else
- local_node->constvalue = readDatum(local_node->constbyval);
-
- 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)
-{
- READ_LOCALS(BoolExpr);
-
- /* do-it-yourself enum representation */
- token = pg_strtok(&length); /* skip :boolop */
- token = pg_strtok(&length); /* get field value */
- if (strncmp(token, "and", 3) == 0)
- local_node->boolop = AND_EXPR;
- else if (strncmp(token, "or", 2) == 0)
- local_node->boolop = OR_EXPR;
- else if (strncmp(token, "not", 3) == 0)
- local_node->boolop = NOT_EXPR;
- else
- elog(ERROR, "unrecognized boolop \"%.*s\"", length, token);
-
- READ_NODE_FIELD(args);
- READ_LOCATION_FIELD(location);
-
- 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)
-{
- READ_LOCALS(RangeTblEntry);
-
- /* put alias + eref first to make dump more legible */
- READ_NODE_FIELD(alias);
- READ_NODE_FIELD(eref);
- READ_ENUM_FIELD(rtekind, RTEKind);
-
- switch (local_node->rtekind)
- {
- case RTE_RELATION:
- READ_OID_FIELD(relid);
- READ_CHAR_FIELD(relkind);
- READ_INT_FIELD(rellockmode);
- READ_NODE_FIELD(tablesample);
- break;
- case RTE_SUBQUERY:
- READ_NODE_FIELD(subquery);
- READ_BOOL_FIELD(security_barrier);
- break;
- case RTE_JOIN:
- READ_ENUM_FIELD(jointype, JoinType);
- READ_INT_FIELD(joinmergedcols);
- READ_NODE_FIELD(joinaliasvars);
- READ_NODE_FIELD(joinleftcols);
- READ_NODE_FIELD(joinrightcols);
- READ_NODE_FIELD(join_using_alias);
- break;
- case RTE_FUNCTION:
- READ_NODE_FIELD(functions);
- READ_BOOL_FIELD(funcordinality);
- break;
- case RTE_TABLEFUNC:
- READ_NODE_FIELD(tablefunc);
- /* The RTE must have a copy of the column type info, if any */
- if (local_node->tablefunc)
- {
- TableFunc *tf = local_node->tablefunc;
-
- local_node->coltypes = tf->coltypes;
- local_node->coltypmods = tf->coltypmods;
- local_node->colcollations = tf->colcollations;
- }
- break;
- case RTE_VALUES:
- READ_NODE_FIELD(values_lists);
- READ_NODE_FIELD(coltypes);
- READ_NODE_FIELD(coltypmods);
- READ_NODE_FIELD(colcollations);
- break;
- case RTE_CTE:
- READ_STRING_FIELD(ctename);
- READ_UINT_FIELD(ctelevelsup);
- READ_BOOL_FIELD(self_reference);
- READ_NODE_FIELD(coltypes);
- READ_NODE_FIELD(coltypmods);
- READ_NODE_FIELD(colcollations);
- break;
- case RTE_NAMEDTUPLESTORE:
- READ_STRING_FIELD(enrname);
- READ_FLOAT_FIELD(enrtuples);
- READ_OID_FIELD(relid);
- READ_NODE_FIELD(coltypes);
- READ_NODE_FIELD(coltypmods);
- READ_NODE_FIELD(colcollations);
- break;
- case RTE_RESULT:
- /* no extra fields */
- break;
- default:
- elog(ERROR, "unrecognized RTE kind: %d",
- (int) local_node->rtekind);
- break;
- }
-
- READ_BOOL_FIELD(lateral);
- READ_BOOL_FIELD(inh);
- READ_BOOL_FIELD(inFromCl);
- READ_UINT_FIELD(requiredPerms);
- READ_OID_FIELD(checkAsUser);
- READ_BITMAPSET_FIELD(selectedCols);
- READ_BITMAPSET_FIELD(insertedCols);
- READ_BITMAPSET_FIELD(updatedCols);
- READ_BITMAPSET_FIELD(extraUpdatedCols);
- READ_NODE_FIELD(securityQuals);
-
- 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)
-{
- const ExtensibleNodeMethods *methods;
- ExtensibleNode *local_node;
- const char *extnodename;
-
- READ_TEMP_LOCALS();
-
- token = pg_strtok(&length); /* skip :extnodename */
- token = pg_strtok(&length); /* get extnodename */
-
- extnodename = nullable_string(token, length);
- if (!extnodename)
- elog(ERROR, "extnodename has to be supplied");
- methods = GetExtensibleNodeMethods(extnodename, false);
-
- local_node = (ExtensibleNode *) newNode(methods->node_size,
- T_ExtensibleNode);
- local_node->extnodename = extnodename;
-
- /* deserialize the private fields */
- methods->nodeRead(local_node);
-
- 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
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);
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;
/*
projects / postgresql.git / commitdiff