1 /*-------------------------------------------------------------------------
4 * Copy functions for Postgres tree nodes.
6 * Copyright (c) 1994, Regents of the University of California
10 * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.94 1999/11/01 05:15:13 tgl Exp $
12 *-------------------------------------------------------------------------
17 #include "optimizer/planmain.h"
18 #include "optimizer/subselect.h"
23 * a macro to simplify calling of copyObject on the specified field
25 #define Node_Copy(from, newnode, field) \
26 ((newnode)->field = copyObject((from)->field))
31 * This copy function only copies the "cons-cells" of the list, not the
32 * pointed-to objects. (Use copyObject if you want a "deep" copy.)
34 * We also use this function for copying lists of integers, which is
35 * grotty but unlikely to break --- it could fail if sizeof(pointer)
36 * is less than sizeof(int), but I don't know any such machines...
38 * Note that copyObject will surely coredump if applied to a list
48 /* rather ugly coding for speed... */
52 newlist = nl = lcons(lfirst(list), NIL);
54 foreach(l, lnext(list))
56 lnext(nl) = lcons(lfirst(l), NIL);
62 /* ****************************************************************
63 * plannodes.h copy functions
64 * ****************************************************************
70 * This function copies the fields of the Plan node. It is used by
71 * all the copy functions for classes which inherit from Plan.
75 CopyPlanFields(Plan *from, Plan *newnode)
77 newnode->cost = from->cost;
78 newnode->plan_size = from->plan_size;
79 newnode->plan_width = from->plan_width;
80 newnode->plan_tupperpage = from->plan_tupperpage;
81 newnode->targetlist = copyObject(from->targetlist);
82 newnode->qual = copyObject(from->qual);
83 newnode->lefttree = copyObject(from->lefttree);
84 newnode->righttree = copyObject(from->righttree);
85 newnode->extParam = listCopy(from->extParam);
86 newnode->locParam = listCopy(from->locParam);
87 newnode->chgParam = listCopy(from->chgParam);
88 Node_Copy(from, newnode, initPlan);
89 if (from->subPlan != NULL)
90 newnode->subPlan = SS_pull_subplan((Node *) newnode->qual);
92 newnode->subPlan = NULL;
93 newnode->nParamExec = from->nParamExec;
101 _copyPlan(Plan *from)
103 Plan *newnode = makeNode(Plan);
106 * copy the node superclass fields
109 CopyPlanFields(from, newnode);
120 _copyResult(Result *from)
122 Result *newnode = makeNode(Result);
125 * copy node superclass fields
128 CopyPlanFields((Plan *) from, (Plan *) newnode);
131 * copy remainder of node
134 Node_Copy(from, newnode, resconstantqual);
137 * We must add subplans in resconstantqual to the new plan's subPlan
140 newnode->plan.subPlan = nconc(newnode->plan.subPlan,
141 SS_pull_subplan(newnode->resconstantqual));
151 _copyAppend(Append *from)
153 Append *newnode = makeNode(Append);
156 * copy node superclass fields
159 CopyPlanFields((Plan *) from, (Plan *) newnode);
162 * copy remainder of node
165 Node_Copy(from, newnode, appendplans);
166 Node_Copy(from, newnode, unionrtables);
167 newnode->inheritrelid = from->inheritrelid;
168 Node_Copy(from, newnode, inheritrtable);
177 * This function copies the fields of the Scan node. It is used by
178 * all the copy functions for classes which inherit from Scan.
182 CopyScanFields(Scan *from, Scan *newnode)
184 newnode->scanrelid = from->scanrelid;
193 _copyScan(Scan *from)
195 Scan *newnode = makeNode(Scan);
198 * copy node superclass fields
201 CopyPlanFields((Plan *) from, (Plan *) newnode);
202 CopyScanFields((Scan *) from, (Scan *) newnode);
212 _copySeqScan(SeqScan *from)
214 SeqScan *newnode = makeNode(SeqScan);
217 * copy node superclass fields
220 CopyPlanFields((Plan *) from, (Plan *) newnode);
221 CopyScanFields((Scan *) from, (Scan *) newnode);
231 _copyIndexScan(IndexScan *from)
233 IndexScan *newnode = makeNode(IndexScan);
236 * copy node superclass fields
239 CopyPlanFields((Plan *) from, (Plan *) newnode);
240 CopyScanFields((Scan *) from, (Scan *) newnode);
243 * copy remainder of node
246 newnode->indxid = listCopy(from->indxid);
247 Node_Copy(from, newnode, indxqual);
248 Node_Copy(from, newnode, indxqualorig);
249 newnode->indxorderdir = from->indxorderdir;
257 * This function copies the fields of the Join node. It is used by
258 * all the copy functions for classes which inherit from Join.
262 CopyJoinFields(Join *from, Join *newnode)
274 _copyJoin(Join *from)
276 Join *newnode = makeNode(Join);
279 * copy node superclass fields
282 CopyPlanFields((Plan *) from, (Plan *) newnode);
283 CopyJoinFields(from, newnode);
294 _copyNestLoop(NestLoop *from)
296 NestLoop *newnode = makeNode(NestLoop);
299 * copy node superclass fields
302 CopyPlanFields((Plan *) from, (Plan *) newnode);
303 CopyJoinFields((Join *) from, (Join *) newnode);
314 _copyMergeJoin(MergeJoin *from)
316 MergeJoin *newnode = makeNode(MergeJoin);
319 * copy node superclass fields
322 CopyPlanFields((Plan *) from, (Plan *) newnode);
323 CopyJoinFields((Join *) from, (Join *) newnode);
326 * copy remainder of node
329 Node_Copy(from, newnode, mergeclauses);
339 _copyHashJoin(HashJoin *from)
341 HashJoin *newnode = makeNode(HashJoin);
344 * copy node superclass fields
347 CopyPlanFields((Plan *) from, (Plan *) newnode);
348 CopyJoinFields((Join *) from, (Join *) newnode);
351 * copy remainder of node
354 Node_Copy(from, newnode, hashclauses);
356 newnode->hashjoinop = from->hashjoinop;
365 * This function copies the fields of the Noname node. It is used by
366 * all the copy functions for classes which inherit from Noname.
370 CopyNonameFields(Noname *from, Noname *newnode)
372 newnode->nonameid = from->nonameid;
373 newnode->keycount = from->keycount;
383 _copyNoname(Noname *from)
385 Noname *newnode = makeNode(Noname);
388 * copy node superclass fields
391 CopyPlanFields((Plan *) from, (Plan *) newnode);
392 CopyNonameFields(from, newnode);
402 _copyMaterial(Material *from)
404 Material *newnode = makeNode(Material);
407 * copy node superclass fields
410 CopyPlanFields((Plan *) from, (Plan *) newnode);
411 CopyNonameFields((Noname *) from, (Noname *) newnode);
422 _copySort(Sort *from)
424 Sort *newnode = makeNode(Sort);
427 * copy node superclass fields
430 CopyPlanFields((Plan *) from, (Plan *) newnode);
431 CopyNonameFields((Noname *) from, (Noname *) newnode);
442 _copyGroup(Group *from)
444 Group *newnode = makeNode(Group);
446 CopyPlanFields((Plan *) from, (Plan *) newnode);
448 newnode->tuplePerGroup = from->tuplePerGroup;
449 newnode->numCols = from->numCols;
450 newnode->grpColIdx = palloc(from->numCols * sizeof(AttrNumber));
451 memcpy(newnode->grpColIdx, from->grpColIdx, from->numCols * sizeof(AttrNumber));
463 Agg *newnode = makeNode(Agg);
465 CopyPlanFields((Plan *) from, (Plan *) newnode);
475 _copyGroupClause(GroupClause *from)
477 GroupClause *newnode = makeNode(GroupClause);
479 newnode->tleSortGroupRef = from->tleSortGroupRef;
480 newnode->sortop = from->sortop;
491 _copyUnique(Unique *from)
493 Unique *newnode = makeNode(Unique);
496 * copy node superclass fields
499 CopyPlanFields((Plan *) from, (Plan *) newnode);
500 CopyNonameFields((Noname *) from, (Noname *) newnode);
503 * copy remainder of node
506 if (from->uniqueAttr)
507 newnode->uniqueAttr = pstrdup(from->uniqueAttr);
509 newnode->uniqueAttr = NULL;
510 newnode->uniqueAttrNum = from->uniqueAttrNum;
521 _copyHash(Hash *from)
523 Hash *newnode = makeNode(Hash);
526 * copy node superclass fields
529 CopyPlanFields((Plan *) from, (Plan *) newnode);
532 * copy remainder of node
535 Node_Copy(from, newnode, hashkey);
541 _copySubPlan(SubPlan *from)
543 SubPlan *newnode = makeNode(SubPlan);
545 Node_Copy(from, newnode, plan);
546 newnode->plan_id = from->plan_id;
547 Node_Copy(from, newnode, rtable);
548 newnode->setParam = listCopy(from->setParam);
549 newnode->parParam = listCopy(from->parParam);
550 Node_Copy(from, newnode, sublink);
555 /* ****************************************************************
556 * primnodes.h copy functions
557 * ****************************************************************
565 _copyResdom(Resdom *from)
567 Resdom *newnode = makeNode(Resdom);
569 newnode->resno = from->resno;
570 newnode->restype = from->restype;
571 newnode->restypmod = from->restypmod;
572 if (from->resname != NULL)
573 newnode->resname = pstrdup(from->resname);
574 newnode->ressortgroupref = from->ressortgroupref;
575 newnode->reskey = from->reskey;
576 newnode->reskeyop = from->reskeyop;
577 newnode->resjunk = from->resjunk;
583 _copyFjoin(Fjoin *from)
585 Fjoin *newnode = makeNode(Fjoin);
588 * copy node superclass fields
592 newnode->fj_initialized = from->fj_initialized;
593 newnode->fj_nNodes = from->fj_nNodes;
595 Node_Copy(from, newnode, fj_innerNode);
597 newnode->fj_results = (DatumPtr)
598 palloc((from->fj_nNodes) * sizeof(Datum));
599 memmove(from->fj_results,
601 (from->fj_nNodes) * sizeof(Datum));
603 newnode->fj_alwaysDone = (BoolPtr)
604 palloc((from->fj_nNodes) * sizeof(bool));
605 memmove(from->fj_alwaysDone,
606 newnode->fj_alwaysDone,
607 (from->fj_nNodes) * sizeof(bool));
618 _copyExpr(Expr *from)
620 Expr *newnode = makeNode(Expr);
623 * copy node superclass fields
626 newnode->typeOid = from->typeOid;
627 newnode->opType = from->opType;
629 Node_Copy(from, newnode, oper);
630 Node_Copy(from, newnode, args);
642 Var *newnode = makeNode(Var);
645 * copy remainder of node
648 newnode->varno = from->varno;
649 newnode->varattno = from->varattno;
650 newnode->vartype = from->vartype;
651 newnode->vartypmod = from->vartypmod;
652 newnode->varlevelsup = from->varlevelsup;
654 newnode->varnoold = from->varnoold;
655 newnode->varoattno = from->varoattno;
665 _copyOper(Oper *from)
667 Oper *newnode = makeNode(Oper);
670 * copy remainder of node
673 newnode->opno = from->opno;
674 newnode->opid = from->opid;
675 newnode->opresulttype = from->opresulttype;
676 newnode->opsize = from->opsize;
679 * NOTE: shall we copy the cache structure or just the pointer ?
680 * Alternatively we can set 'op_fcache' to NULL, in which case the
681 * executor will initialize it when it needs it...
683 newnode->op_fcache = from->op_fcache;
693 _copyConst(Const *from)
695 Const *newnode = makeNode(Const);
698 * copy remainder of node
701 newnode->consttype = from->consttype;
702 newnode->constlen = from->constlen;
704 if (from->constbyval || from->constisnull)
707 * passed by value so just copy the datum.
708 * Also, don't try to copy struct when value is null!
711 newnode->constvalue = from->constvalue;
716 * not passed by value. datum contains a pointer.
719 int length = from->constlen;
721 if (length == -1) /* variable-length type? */
722 length = VARSIZE(from->constvalue);
723 newnode->constvalue = PointerGetDatum(palloc(length));
724 memcpy(DatumGetPointer(newnode->constvalue),
725 DatumGetPointer(from->constvalue),
729 newnode->constisnull = from->constisnull;
730 newnode->constbyval = from->constbyval;
731 newnode->constisset = from->constisset;
732 newnode->constiscast = from->constiscast;
742 _copyParam(Param *from)
744 Param *newnode = makeNode(Param);
747 * copy remainder of node
750 newnode->paramkind = from->paramkind;
751 newnode->paramid = from->paramid;
753 if (from->paramname != NULL)
754 newnode->paramname = pstrdup(from->paramname);
755 newnode->paramtype = from->paramtype;
756 Node_Copy(from, newnode, param_tlist);
766 _copyFunc(Func *from)
768 Func *newnode = makeNode(Func);
771 * copy remainder of node
774 newnode->funcid = from->funcid;
775 newnode->functype = from->functype;
776 newnode->funcisindex = from->funcisindex;
777 newnode->funcsize = from->funcsize;
778 newnode->func_fcache = from->func_fcache;
779 Node_Copy(from, newnode, func_tlist);
780 Node_Copy(from, newnode, func_planlist);
790 _copyAggref(Aggref *from)
792 Aggref *newnode = makeNode(Aggref);
795 * copy remainder of node
798 newnode->aggname = pstrdup(from->aggname);
799 newnode->basetype = from->basetype;
800 newnode->aggtype = from->aggtype;
801 Node_Copy(from, newnode, target);
802 newnode->usenulls = from->usenulls;
803 newnode->aggno = from->aggno; /* probably not needed */
813 _copySubLink(SubLink *from)
815 SubLink *newnode = makeNode(SubLink);
818 * copy remainder of node
821 newnode->subLinkType = from->subLinkType;
822 newnode->useor = from->useor;
823 Node_Copy(from, newnode, lefthand);
824 Node_Copy(from, newnode, oper);
825 Node_Copy(from, newnode, subselect);
835 _copyCaseExpr(CaseExpr *from)
837 CaseExpr *newnode = makeNode(CaseExpr);
840 * copy remainder of node
843 newnode->casetype = from->casetype;
845 Node_Copy(from, newnode, arg);
846 Node_Copy(from, newnode, args);
847 Node_Copy(from, newnode, defresult);
857 _copyCaseWhen(CaseWhen *from)
859 CaseWhen *newnode = makeNode(CaseWhen);
862 * copy remainder of node
865 Node_Copy(from, newnode, expr);
866 Node_Copy(from, newnode, result);
872 _copyArray(Array *from)
874 Array *newnode = makeNode(Array);
877 * copy remainder of node
880 newnode->arrayelemtype = from->arrayelemtype;
881 newnode->arrayelemlength = from->arrayelemlength;
882 newnode->arrayelembyval = from->arrayelembyval;
883 newnode->arrayndim = from->arrayndim;
884 newnode->arraylow = from->arraylow;
885 newnode->arrayhigh = from->arrayhigh;
886 newnode->arraylen = from->arraylen;
892 _copyArrayRef(ArrayRef *from)
894 ArrayRef *newnode = makeNode(ArrayRef);
897 * copy remainder of node
900 newnode->refattrlength = from->refattrlength;
901 newnode->refelemlength = from->refelemlength;
902 newnode->refelemtype = from->refelemtype;
903 newnode->refelembyval = from->refelembyval;
905 Node_Copy(from, newnode, refupperindexpr);
906 Node_Copy(from, newnode, reflowerindexpr);
907 Node_Copy(from, newnode, refexpr);
908 Node_Copy(from, newnode, refassgnexpr);
913 /* ****************************************************************
914 * relation.h copy functions
915 * ****************************************************************
923 * when you change this, also make sure to fix up xfunc_copyRelOptInfo in
924 * planner/path/xfunc.c accordingly!!!
928 _copyRelOptInfo(RelOptInfo *from)
930 RelOptInfo *newnode = makeNode(RelOptInfo);
935 * copy remainder of node
938 newnode->relids = listCopy(from->relids);
940 newnode->indexed = from->indexed;
941 newnode->pages = from->pages;
942 newnode->tuples = from->tuples;
943 newnode->size = from->size;
944 newnode->width = from->width;
945 Node_Copy(from, newnode, targetlist);
946 Node_Copy(from, newnode, pathlist);
947 Node_Copy(from, newnode, cheapestpath);
948 newnode->pruneable = from->pruneable;
952 for (len = 0; from->classlist[len] != 0; len++)
954 newnode->classlist = (Oid *) palloc(sizeof(Oid) * (len + 1));
955 for (i = 0; i < len; i++)
956 newnode->classlist[i] = from->classlist[i];
957 newnode->classlist[len] = 0;
962 for (len = 0; from->indexkeys[len] != 0; len++)
964 newnode->indexkeys = (int *) palloc(sizeof(int) * (len + 1));
965 for (i = 0; i < len; i++)
966 newnode->indexkeys[i] = from->indexkeys[i];
967 newnode->indexkeys[len] = 0;
972 for (len = 0; from->ordering[len] != 0; len++)
974 newnode->ordering = (Oid *) palloc(sizeof(Oid) * (len + 1));
975 for (i = 0; i < len; i++)
976 newnode->ordering[i] = from->ordering[i];
977 newnode->ordering[len] = 0;
980 newnode->relam = from->relam;
981 newnode->indproc = from->indproc;
982 Node_Copy(from, newnode, indpred);
984 Node_Copy(from, newnode, restrictinfo);
985 Node_Copy(from, newnode, joininfo);
986 Node_Copy(from, newnode, innerjoin);
994 * This function copies the fields of the Path node. It is used by
995 * all the copy functions for classes which inherit from Path.
999 CopyPathFields(Path *from, Path *newnode)
1002 * Modify the next line, since it causes the copying to cycle (i.e.
1003 * the parent points right back here! -- JMH, 7/7/92. Old version:
1004 * Node_Copy(from, newnode, parent);
1006 newnode->parent = from->parent;
1008 newnode->path_cost = from->path_cost;
1010 newnode->pathtype = from->pathtype;
1012 Node_Copy(from, newnode, pathkeys);
1020 _copyPath(Path *from)
1022 Path *newnode = makeNode(Path);
1024 CopyPathFields(from, newnode);
1034 _copyIndexPath(IndexPath *from)
1036 IndexPath *newnode = makeNode(IndexPath);
1039 * copy the node superclass fields
1042 CopyPathFields((Path *) from, (Path *) newnode);
1045 * copy remainder of node
1048 newnode->indexid = listCopy(from->indexid);
1049 Node_Copy(from, newnode, indexqual);
1050 newnode->joinrelids = listCopy(from->joinrelids);
1056 * CopyJoinPathFields
1058 * This function copies the fields of the JoinPath node. It is used by
1059 * all the copy functions for classes which inherit from JoinPath.
1063 CopyJoinPathFields(JoinPath *from, JoinPath *newnode)
1065 Node_Copy(from, newnode, pathinfo);
1066 Node_Copy(from, newnode, outerjoinpath);
1067 Node_Copy(from, newnode, innerjoinpath);
1075 _copyNestPath(NestPath *from)
1077 NestPath *newnode = makeNode(NestPath);
1080 * copy the node superclass fields
1083 CopyPathFields((Path *) from, (Path *) newnode);
1084 CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
1094 _copyMergePath(MergePath *from)
1096 MergePath *newnode = makeNode(MergePath);
1099 * copy the node superclass fields
1102 CopyPathFields((Path *) from, (Path *) newnode);
1103 CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
1106 * copy the remainder of the node
1109 Node_Copy(from, newnode, path_mergeclauses);
1110 Node_Copy(from, newnode, outersortkeys);
1111 Node_Copy(from, newnode, innersortkeys);
1121 _copyHashPath(HashPath *from)
1123 HashPath *newnode = makeNode(HashPath);
1126 * copy the node superclass fields
1129 CopyPathFields((Path *) from, (Path *) newnode);
1130 CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
1133 * copy remainder of node
1136 Node_Copy(from, newnode, path_hashclauses);
1145 static PathKeyItem *
1146 _copyPathKeyItem(PathKeyItem *from)
1148 PathKeyItem *newnode = makeNode(PathKeyItem);
1151 * copy remainder of node
1154 Node_Copy(from, newnode, key);
1155 newnode->sortop = from->sortop;
1164 static RestrictInfo *
1165 _copyRestrictInfo(RestrictInfo *from)
1167 RestrictInfo *newnode = makeNode(RestrictInfo);
1170 * copy remainder of node
1173 Node_Copy(from, newnode, clause);
1174 newnode->selectivity = from->selectivity;
1175 Node_Copy(from, newnode, subclauseindices);
1176 newnode->mergejoinoperator = from->mergejoinoperator;
1177 newnode->left_sortop = from->left_sortop;
1178 newnode->right_sortop = from->right_sortop;
1179 newnode->hashjoinoperator = from->hashjoinoperator;
1189 _copyJoinInfo(JoinInfo *from)
1191 JoinInfo *newnode = makeNode(JoinInfo);
1194 * copy remainder of node
1197 newnode->unjoined_relids = listCopy(from->unjoined_relids);
1198 Node_Copy(from, newnode, jinfo_restrictinfo);
1204 _copyIter(Iter *from)
1206 Iter *newnode = makeNode(Iter);
1208 Node_Copy(from, newnode, iterexpr);
1209 newnode->itertype = from->itertype;
1215 _copyStream(Stream *from)
1217 Stream *newnode = makeNode(Stream);
1219 newnode->pathptr = from->pathptr;
1220 newnode->cinfo = from->cinfo;
1221 newnode->clausetype = from->clausetype;
1223 newnode->upstream = (StreamPtr) NULL; /* only copy nodes
1225 Node_Copy(from, newnode, downstream);
1226 if (newnode->downstream)
1227 ((Stream *) newnode->downstream)->upstream = (Stream *) newnode;
1229 newnode->groupup = from->groupup;
1230 newnode->groupcost = from->groupcost;
1231 newnode->groupsel = from->groupsel;
1237 * parsenodes.h routines have no copy functions
1240 static TargetEntry *
1241 _copyTargetEntry(TargetEntry *from)
1243 TargetEntry *newnode = makeNode(TargetEntry);
1245 Node_Copy(from, newnode, resdom);
1246 Node_Copy(from, newnode, fjoin);
1247 Node_Copy(from, newnode, expr);
1251 static RangeTblEntry *
1252 _copyRangeTblEntry(RangeTblEntry *from)
1254 RangeTblEntry *newnode = makeNode(RangeTblEntry);
1257 newnode->relname = pstrdup(from->relname);
1259 newnode->refname = pstrdup(from->refname);
1260 newnode->relid = from->relid;
1261 newnode->inh = from->inh;
1262 newnode->inFromCl = from->inFromCl;
1263 newnode->inJoinSet = from->inJoinSet;
1264 newnode->skipAcl = from->skipAcl;
1270 _copyRowMark(RowMark *from)
1272 RowMark *newnode = makeNode(RowMark);
1274 newnode->rti = from->rti;
1275 newnode->info = from->info;
1281 _copySortClause(SortClause *from)
1283 SortClause *newnode = makeNode(SortClause);
1285 newnode->tleSortGroupRef = from->tleSortGroupRef;
1286 newnode->sortop = from->sortop;
1292 _copyAConst(A_Const *from)
1294 A_Const *newnode = makeNode(A_Const);
1296 newnode->val = *((Value *) (copyObject(&(from->val))));
1297 Node_Copy(from, newnode, typename);
1303 _copyTypeName(TypeName *from)
1305 TypeName *newnode = makeNode(TypeName);
1308 newnode->name = pstrdup(from->name);
1309 newnode->timezone = from->timezone;
1310 newnode->setof = from->setof;
1311 newnode->typmod = from->typmod;
1312 Node_Copy(from, newnode, arrayBounds);
1318 _copyQuery(Query *from)
1320 Query *newnode = makeNode(Query);
1322 newnode->commandType = from->commandType;
1323 if (from->utilityStmt && nodeTag(from->utilityStmt) == T_NotifyStmt)
1325 NotifyStmt *from_notify = (NotifyStmt *) from->utilityStmt;
1326 NotifyStmt *n = makeNode(NotifyStmt);
1328 n->relname = pstrdup(from_notify->relname);
1329 newnode->utilityStmt = (Node *) n;
1331 newnode->resultRelation = from->resultRelation;
1333 newnode->into = pstrdup(from->into);
1334 newnode->isPortal = from->isPortal;
1335 newnode->isBinary = from->isBinary;
1336 newnode->isTemp = from->isTemp;
1337 newnode->unionall = from->unionall;
1338 newnode->hasAggs = from->hasAggs;
1339 newnode->hasSubLinks = from->hasSubLinks;
1341 Node_Copy(from, newnode, rtable);
1342 Node_Copy(from, newnode, targetList);
1343 Node_Copy(from, newnode, qual);
1344 Node_Copy(from, newnode, rowMark);
1346 if (from->uniqueFlag)
1347 newnode->uniqueFlag = pstrdup(from->uniqueFlag);
1348 Node_Copy(from, newnode, sortClause);
1349 Node_Copy(from, newnode, groupClause);
1350 Node_Copy(from, newnode, havingQual);
1352 /* why is intersectClause missing? */
1353 Node_Copy(from, newnode, unionClause);
1355 Node_Copy(from, newnode, limitOffset);
1356 Node_Copy(from, newnode, limitCount);
1358 /* we do not copy the planner internal fields: base_rel_list,
1359 * join_rel_list, query_pathkeys. Not entirely clear if this is right?
1367 * mnodes.h routines have no copy functions
1370 /* ****************************************************************
1371 * pg_list.h copy functions
1372 * ****************************************************************
1376 _copyValue(Value *from)
1378 Value *newnode = makeNode(Value);
1380 newnode->type = from->type;
1384 newnode->val.str = pstrdup(from->val.str);
1387 newnode->val.ival = from->val.ival;
1390 newnode->val.dval = from->val.dval;
1399 * copyObject returns a copy of the node or list. If it is a list, it
1400 * recursively copies its items.
1404 copyObject(void *from)
1410 switch (nodeTag(from))
1417 retval = _copyPlan(from);
1420 retval = _copyResult(from);
1423 retval = _copyAppend(from);
1426 retval = _copyScan(from);
1429 retval = _copySeqScan(from);
1432 retval = _copyIndexScan(from);
1435 retval = _copyJoin(from);
1438 retval = _copyNestLoop(from);
1441 retval = _copyMergeJoin(from);
1444 retval = _copyHashJoin(from);
1447 retval = _copyNoname(from);
1450 retval = _copyMaterial(from);
1453 retval = _copySort(from);
1456 retval = _copyGroup(from);
1459 retval = _copyAgg(from);
1462 retval = _copyGroupClause(from);
1465 retval = _copyUnique(from);
1468 retval = _copyHash(from);
1471 retval = _copySubPlan(from);
1478 retval = _copyResdom(from);
1481 retval = _copyFjoin(from);
1484 retval = _copyExpr(from);
1487 retval = _copyVar(from);
1490 retval = _copyOper(from);
1493 retval = _copyConst(from);
1496 retval = _copyParam(from);
1499 retval = _copyFunc(from);
1502 retval = _copyArray(from);
1505 retval = _copyArrayRef(from);
1508 retval = _copyAggref(from);
1511 retval = _copySubLink(from);
1514 retval = _copyCaseExpr(from);
1517 retval = _copyCaseWhen(from);
1524 retval = _copyRelOptInfo(from);
1527 retval = _copyPath(from);
1530 retval = _copyIndexPath(from);
1533 retval = _copyNestPath(from);
1536 retval = _copyMergePath(from);
1539 retval = _copyHashPath(from);
1542 retval = _copyPathKeyItem(from);
1544 case T_RestrictInfo:
1545 retval = _copyRestrictInfo(from);
1548 retval = _copyJoinInfo(from);
1551 retval = _copyIter(from);
1554 retval = _copyStream(from);
1561 retval = _copyQuery(from);
1564 retval = _copyTargetEntry(from);
1566 case T_RangeTblEntry:
1567 retval = _copyRangeTblEntry(from);
1570 retval = _copyRowMark(from);
1573 retval = _copySortClause(from);
1576 retval = _copyAConst(from);
1579 retval = _copyTypeName(from);
1588 retval = _copyValue(from);
1596 /* rather ugly coding for speed... */
1597 /* Note the input list cannot be NIL if we got here. */
1598 nl = lcons(copyObject(lfirst(list)), NIL);
1601 foreach(l, lnext(list))
1603 lnext(nl) = lcons(copyObject(lfirst(l)), NIL);
1609 elog(ERROR, "copyObject: don't know how to copy %d", nodeTag(from));