/src/backend/nodes/copyfuncs.c
C | 4644 lines | 3299 code | 759 blank | 586 comment | 14 complexity | 52454c2b24489e3b9b1e6368764e2ef8 MD5 | raw file
Possible License(s): AGPL-3.0
Large files files are truncated, but you can click here to view the full file
- /*-------------------------------------------------------------------------
- *
- * 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-2014, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * IDENTIFICATION
- * src/backend/nodes/copyfuncs.c
- *
- *-------------------------------------------------------------------------
- */
- #include "postgres.h"
- #include "miscadmin.h"
- #include "nodes/plannodes.h"
- #include "nodes/relation.h"
- #include "utils/datum.h"
- /*
- * Macros to simplify copying of different kinds of fields. Use these
- * wherever possible to reduce the chance for silly typos. Note that these
- * hard-wire the convention that the local variables in a Copy routine are
- * named 'newnode' and 'from'.
- */
- /* Copy a simple scalar field (int, float, bool, enum, etc) */
- #define COPY_SCALAR_FIELD(fldname) \
- (newnode->fldname = from->fldname)
- /* Copy a field that is a pointer to some kind of Node or Node tree */
- #define COPY_NODE_FIELD(fldname) \
- (newnode->fldname = copyObject(from->fldname))
- /* Copy a field that is a pointer to a Bitmapset */
- #define COPY_BITMAPSET_FIELD(fldname) \
- (newnode->fldname = bms_copy(from->fldname))
- /* Copy a field that is a pointer to a C string, or perhaps NULL */
- #define COPY_STRING_FIELD(fldname) \
- (newnode->fldname = from->fldname ? pstrdup(from->fldname) : (char *) NULL)
- /* Copy a field that is a pointer to a simple palloc'd object of size sz */
- #define COPY_POINTER_FIELD(fldname, sz) \
- do { \
- Size _size = (sz); \
- newnode->fldname = palloc(_size); \
- memcpy(newnode->fldname, from->fldname, _size); \
- } while (0)
- /* Copy a parse location field (for Copy, this is same as scalar case) */
- #define COPY_LOCATION_FIELD(fldname) \
- (newnode->fldname = from->fldname)
- /* ****************************************************************
- * 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_NODE_FIELD(planTree);
- COPY_NODE_FIELD(rtable);
- COPY_NODE_FIELD(resultRelations);
- COPY_NODE_FIELD(utilityStmt);
- COPY_NODE_FIELD(subplans);
- COPY_BITMAPSET_FIELD(rewindPlanIDs);
- COPY_NODE_FIELD(rowMarks);
- COPY_NODE_FIELD(relationOids);
- COPY_NODE_FIELD(invalItems);
- COPY_SCALAR_FIELD(nParamExec);
- 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_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);
- }
- /*
- * _copyPlan
- */
- static Plan *
- _copyPlan(const Plan *from)
- {
- Plan *newnode = makeNode(Plan);
- /*
- * copy node superclass fields
- */
- CopyPlanFields(from, newnode);
- return newnode;
- }
- /*
- * _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;
- }
- /*
- * _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_NODE_FIELD(resultRelations);
- COPY_SCALAR_FIELD(resultRelIndex);
- COPY_NODE_FIELD(plans);
- COPY_NODE_FIELD(withCheckOptionLists);
- COPY_NODE_FIELD(returningLists);
- COPY_NODE_FIELD(fdwPrivLists);
- COPY_NODE_FIELD(rowMarks);
- COPY_SCALAR_FIELD(epqParam);
- 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_NODE_FIELD(appendplans);
- return newnode;
- }
- /*
- * _copyMergeAppend
- */
- static MergeAppend *
- _copyMergeAppend(const MergeAppend *from)
- {
- MergeAppend *newnode = makeNode(MergeAppend);
- /*
- * copy node superclass fields
- */
- CopyPlanFields((const Plan *) from, (Plan *) newnode);
- /*
- * copy remainder of node
- */
- COPY_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));
- return newnode;
- }
- /*
- * _copyRecursiveUnion
- */
- static RecursiveUnion *
- _copyRecursiveUnion(const RecursiveUnion *from)
- {
- RecursiveUnion *newnode = makeNode(RecursiveUnion);
- /*
- * copy node superclass fields
- */
- CopyPlanFields((const Plan *) from, (Plan *) newnode);
- /*
- * copy remainder of node
- */
- COPY_SCALAR_FIELD(wtParam);
- COPY_SCALAR_FIELD(numCols);
- if (from->numCols > 0)
- {
- COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
- COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
- }
- COPY_SCALAR_FIELD(numGroups);
- return newnode;
- }
- /*
- * _copyBitmapAnd
- */
- static BitmapAnd *
- _copyBitmapAnd(const BitmapAnd *from)
- {
- BitmapAnd *newnode = makeNode(BitmapAnd);
- /*
- * copy node superclass fields
- */
- CopyPlanFields((const Plan *) from, (Plan *) newnode);
- /*
- * copy remainder of node
- */
- COPY_NODE_FIELD(bitmapplans);
- return newnode;
- }
- /*
- * _copyBitmapOr
- */
- static BitmapOr *
- _copyBitmapOr(const BitmapOr *from)
- {
- BitmapOr *newnode = makeNode(BitmapOr);
- /*
- * copy node superclass fields
- */
- CopyPlanFields((const Plan *) from, (Plan *) newnode);
- /*
- * copy remainder of node
- */
- COPY_NODE_FIELD(bitmapplans);
- return newnode;
- }
- /*
- * CopyScanFields
- *
- * This function copies the fields of the Scan node. It is used by
- * all the copy functions for classes which inherit from Scan.
- */
- static void
- CopyScanFields(const Scan *from, Scan *newnode)
- {
- CopyPlanFields((const Plan *) from, (Plan *) newnode);
- COPY_SCALAR_FIELD(scanrelid);
- }
- /*
- * _copyScan
- */
- static Scan *
- _copyScan(const Scan *from)
- {
- Scan *newnode = makeNode(Scan);
- /*
- * copy node superclass fields
- */
- CopyScanFields((const Scan *) from, (Scan *) newnode);
- return newnode;
- }
- /*
- * _copySeqScan
- */
- static SeqScan *
- _copySeqScan(const SeqScan *from)
- {
- SeqScan *newnode = makeNode(SeqScan);
- /*
- * copy node superclass fields
- */
- CopyScanFields((const Scan *) from, (Scan *) newnode);
- return newnode;
- }
- /*
- * _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_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(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_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;
- }
- /*
- * _copySubqueryScan
- */
- static SubqueryScan *
- _copySubqueryScan(const SubqueryScan *from)
- {
- SubqueryScan *newnode = makeNode(SubqueryScan);
- /*
- * copy node superclass fields
- */
- CopyScanFields((const Scan *) from, (Scan *) newnode);
- /*
- * copy remainder of node
- */
- COPY_NODE_FIELD(subplan);
- return newnode;
- }
- /*
- * _copyFunctionScan
- */
- static FunctionScan *
- _copyFunctionScan(const FunctionScan *from)
- {
- FunctionScan *newnode = makeNode(FunctionScan);
- /*
- * copy node superclass fields
- */
- CopyScanFields((const Scan *) from, (Scan *) newnode);
- /*
- * copy remainder of node
- */
- COPY_NODE_FIELD(functions);
- COPY_SCALAR_FIELD(funcordinality);
- return newnode;
- }
- /*
- * _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;
- }
- /*
- * _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_NODE_FIELD(fdw_exprs);
- COPY_NODE_FIELD(fdw_private);
- COPY_SCALAR_FIELD(fsSystemCol);
- 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_NODE_FIELD(joinqual);
- }
- /*
- * _copyJoin
- */
- static Join *
- _copyJoin(const Join *from)
- {
- Join *newnode = makeNode(Join);
- /*
- * copy node superclass fields
- */
- CopyJoinFields(from, newnode);
- return newnode;
- }
- /*
- * _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_NODE_FIELD(mergeclauses);
- numCols = list_length(from->mergeclauses);
- if (numCols > 0)
- {
- 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);
- 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;
- }
- /*
- * _copySort
- */
- static Sort *
- _copySort(const Sort *from)
- {
- Sort *newnode = makeNode(Sort);
- /*
- * copy node superclass fields
- */
- 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));
- 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));
- 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(numCols);
- if (from->numCols > 0)
- {
- COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
- COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
- }
- COPY_SCALAR_FIELD(numGroups);
- 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);
- if (from->partNumCols > 0)
- {
- COPY_POINTER_FIELD(partColIdx, from->partNumCols * sizeof(AttrNumber));
- COPY_POINTER_FIELD(partOperators, from->partNumCols * sizeof(Oid));
- }
- COPY_SCALAR_FIELD(ordNumCols);
- if (from->ordNumCols > 0)
- {
- COPY_POINTER_FIELD(ordColIdx, from->ordNumCols * sizeof(AttrNumber));
- COPY_POINTER_FIELD(ordOperators, from->ordNumCols * sizeof(Oid));
- }
- COPY_SCALAR_FIELD(frameOptions);
- COPY_NODE_FIELD(startOffset);
- COPY_NODE_FIELD(endOffset);
- 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));
- 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_SCALAR_FIELD(skewTable);
- COPY_SCALAR_FIELD(skewColumn);
- COPY_SCALAR_FIELD(skewInherit);
- COPY_SCALAR_FIELD(skewColType);
- COPY_SCALAR_FIELD(skewColTypmod);
- 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_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);
- 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(noWait);
- COPY_SCALAR_FIELD(isParent);
- 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(inhOpt);
- COPY_SCALAR_FIELD(relpersistence);
- COPY_NODE_FIELD(alias);
- 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_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(varnoold);
- COPY_SCALAR_FIELD(varoattno);
- COPY_LOCATION_FIELD(location);
- return newnode;
- }
- /*
- * _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;
- }
- /*
- * _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_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_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;
- }
- /*
- * _copyArrayRef
- */
- static ArrayRef *
- _copyArrayRef(const ArrayRef *from)
- {
- ArrayRef *newnode = makeNode(ArrayRef);
- COPY_SCALAR_FIELD(refarraytype);
- COPY_SCALAR_FIELD(refelemtype);
- 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(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_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_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_SCALAR_FIELD(elemfuncid);
- COPY_SCALAR_FIELD(resulttype);
- COPY_SCALAR_FIELD(resulttypmod);
- COPY_SCALAR_FIELD(resultcollid);
- COPY_SCALAR_FIELD(isExplicit);
- 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;
- }
- /*
- * _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);
- return newnode;
- }
- /*
- * _copyBooleanTest
- */
- static BooleanTest *
- _copyBooleanTest(const BooleanTest *from)
- {
- BooleanTest *newnode = makeNode(BooleanTest);
- COPY_NODE_FIELD(arg);
- COPY_SCALAR_FIELD(booltesttype);
- 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;
- }
- /*
- * _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(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;
- }
- /* ****************************************************************
- * relation.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_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);
- 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_NODE_FIELD(join_quals);
- return newnode;
- }
- /*
- * _copyLateralJoinInfo
- */
- static LateralJoinInfo *
- _copyLateralJoinInfo(const LateralJoinInfo *from)
- {
- LateralJoinInfo *newnode = makeNode(LateralJoinInfo);
- COPY_BITMAPSET_FIELD(lateral_lhs);
- COPY_BITMAPSET_FIELD(lateral_rhs);
- 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(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_NODE_FIELD(subquery);
- COPY_SCALAR_FIELD(security_barrier);
- COPY_SCALAR_FIELD(jointype);
- COPY_NODE_FIELD(joinaliasvars);
- COPY_NODE_FIELD(functions);
- COPY_SCALAR_FIELD(funcordinality);
- COPY_NODE_FIELD(values_lists);
- COPY_NODE_FIELD(values_collations);
- COPY_STRING_FIELD(ctename);
- COPY_SCALAR_FIELD(ctelevelsup);
- COPY_SCALAR_FIELD(self_reference);
- COPY_NODE_FIELD(ctecoltypes);
- COPY_NODE_FIELD(ctecoltypmods);
- COPY_NODE_FIELD(ctecolcollations);
- 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(modifiedCols);
- 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 WithCheckOption *
- _copyWithCheckOption(const WithCheckOption *from)
- {
- WithCheckOption *newnode = makeNode(WithCheckOption);
- COPY_STRING_FIELD(viewname);
- 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 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_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(noWait);
- 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 CommonTableExpr *
- _copyCommonTableExpr(const CommonTableExpr *from)
- {
- CommonTableExpr *newnode = makeNode(CommonTableExpr);
- COPY_STRING_FIELD(ctename);
- COPY_NODE_FIELD(aliascolnames);
- COPY_NODE_FIELD(ctequery);
- 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 A_Expr *
- _copyAExpr(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;
- }
- static A_Const *
- _copyAConst(const A_Const *from)
- {
- A_Const *newnode = makeNode(A_Const);
- /* This part must duplicate _copyValue */
- COPY_SCALAR_FIELD(val.type);
- switch (from->val.type)
- {
- case T_Integer:
- COPY_SCALAR_FIELD(val.val.ival);
- break;
- case T_Float:
- case T_String:
- case T_BitString:
- COPY_STRING_FIELD(val.val.str);
- break;
- case T_Null:
- /* nothing to do */
- break;
- default:
- elog(ERROR, "unrecognized node type: %d",
- (int) from->val.type);
- break;
- }
- COPY_LOCATION_FIELD(location);
- return newnode;
- }
- 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_SCALAR_FIELD(agg_within_group);
- COPY_SCALAR_FIELD(agg_star);
- COPY_SCALAR_FIELD(agg_distinct);
- COPY_SCALAR_FIELD(func_variadic);
- COPY_NODE_FIELD(over);
- COPY_LOCATION_FIELD(location);
- return newnode;
- }
- static A_Star *
- _copyAStar(const A_Star *from)
- {
- A_Star *newnode = makeNode(A_Star);
- return newnode;
- }
- static A_Indices *
- _copyAIndices(const A_Indices *from)
- {
- A_Indices *newnode = makeNode(A_Indices);
- 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 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 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_SCALAR_FIELD(ordering);
- COPY_SCALAR_FIELD(nulls_ordering);
- return newnode;
- }
- static ColumnDef *
- _copyColumnDef(const ColumnDef *from)
- {
- ColumnDef *newnode = makeNode(ColumnDef);
- COPY_STRING_FIELD(colname);
- COPY_NODE_FIELD(typeName);
- 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_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_NODE_FIELD(keys);
- COPY_NODE_FIELD(exclusions);
- COPY_NODE_FIELD(options);
- COPY_STRING_FIELD(indexname);
- COPY_STRING_FIELD(indexspace);
- 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(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);
- return newnode;
- }
- static LockingClause *
- _copyLockingClause(const LockingClause *from)
- {
- LockingClause *newnode = makeNode(LockingClause);
- COPY_NODE_FIELD(lockedRels);
- COPY_SCALAR_FIELD(strength);
- COPY_SCALAR_FIELD(noWait);
- 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 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(hasSubLinks);
- COPY_SCALAR_FIELD(hasDistinctOn);
- COPY_SCALAR_FIELD(hasRecursive);
- COPY_SCALAR_FIELD(hasModifyingCTE);
- COPY_SCALAR_FIELD(hasForUpdate);
- COPY_NODE_FIELD(cteList);
- COPY_NODE_FIELD(rtable);
- COPY_NODE_FIELD(jointree);
- COPY_NODE_FIELD(targetList);
- COPY_NODE_FIELD(withCheckOptions);
- COPY_NODE_FIELD(returningList);
- COPY_NODE_FIELD(groupClause);
- 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_NODE_FIELD(rowMarks);
- COPY_NODE_FIELD(setOperations);
- COPY_NODE_FIELD(constraintDeps);
- 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(returningList);
- COPY_NODE_FIELD(withClause);
- return newnode;
- }
- static DeleteStmt *
- _copyDeleteStmt(const DeleteStmt *from)
- {
- DeleteStmt *newnode = makeNode(DeleteStmt);
- COPY_NO…
Large files files are truncated, but you can click here to view the full file