diff options
Diffstat (limited to 'src/backend/nodes/copyfuncs.c')
| -rw-r--r-- | src/backend/nodes/copyfuncs.c | 1949 |
1 files changed, 874 insertions, 1075 deletions
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index da3bf7b7213..0f02b5d119b 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -15,7 +15,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.221 2002/11/24 21:52:13 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.222 2002/11/25 03:33:27 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -28,11 +28,44 @@ /* - * Node_Copy - * a macro to simplify calling of copyObject on the specified field + * 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'. */ -#define Node_Copy(from, newnode, field) \ - ((newnode)->field = copyObject((from)->field)) + +/* 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 list of integers */ +#define COPY_INTLIST_FIELD(fldname) \ + (newnode->fldname = listCopy(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) + +/* Special hack for fixing subplan lists of Plan nodes (ick) */ +#define FIX_SUBPLAN_LINKS(subplanfldname, fldname) \ + do { \ + if (from->subplanfldname != NIL) \ + newnode->subplanfldname = \ + nconc(newnode->subplanfldname, \ + pull_subplans((Node *) (newnode->fldname))); \ + } while (0) /* @@ -73,41 +106,37 @@ listCopy(List *list) * **************************************************************** */ -/* ---------------- - * CopyPlanFields +/* + * 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(Plan *from, Plan *newnode) { - newnode->startup_cost = from->startup_cost; - newnode->total_cost = from->total_cost; - newnode->plan_rows = from->plan_rows; - newnode->plan_width = from->plan_width; - /* state is NOT copied */ - Node_Copy(from, newnode, targetlist); - Node_Copy(from, newnode, qual); - Node_Copy(from, newnode, lefttree); - Node_Copy(from, newnode, righttree); - newnode->extParam = listCopy(from->extParam); - newnode->locParam = listCopy(from->locParam); - newnode->chgParam = listCopy(from->chgParam); - Node_Copy(from, newnode, initPlan); + COPY_SCALAR_FIELD(startup_cost); + COPY_SCALAR_FIELD(total_cost); + COPY_SCALAR_FIELD(plan_rows); + COPY_SCALAR_FIELD(plan_width); + /* execution state is NOT copied */ + COPY_NODE_FIELD(targetlist); + COPY_NODE_FIELD(qual); + COPY_NODE_FIELD(lefttree); + COPY_NODE_FIELD(righttree); + COPY_INTLIST_FIELD(extParam); + COPY_INTLIST_FIELD(locParam); + COPY_INTLIST_FIELD(chgParam); + COPY_NODE_FIELD(initPlan); /* subPlan list must point to subplans in the new subtree, not the old */ - if (from->subPlan != NIL) - newnode->subPlan = nconc(pull_subplans((Node *) newnode->targetlist), - pull_subplans((Node *) newnode->qual)); - else - newnode->subPlan = NIL; - newnode->nParamExec = from->nParamExec; + newnode->subPlan = NIL; + FIX_SUBPLAN_LINKS(subPlan, targetlist); + FIX_SUBPLAN_LINKS(subPlan, qual); + COPY_SCALAR_FIELD(nParamExec); } -/* ---------------- - * _copyPlan - * ---------------- +/* + * _copyPlan */ static Plan * _copyPlan(Plan *from) @@ -115,7 +144,7 @@ _copyPlan(Plan *from) Plan *newnode = makeNode(Plan); /* - * copy the node superclass fields + * copy node superclass fields */ CopyPlanFields(from, newnode); @@ -123,9 +152,8 @@ _copyPlan(Plan *from) } -/* ---------------- - * _copyResult - * ---------------- +/* + * _copyResult */ static Result * _copyResult(Result *from) @@ -140,22 +168,16 @@ _copyResult(Result *from) /* * copy remainder of node */ - Node_Copy(from, newnode, resconstantqual); + COPY_NODE_FIELD(resconstantqual); - /* - * We must add subplans in resconstantqual to the new plan's subPlan - * list - */ - if (from->plan.subPlan != NIL) - newnode->plan.subPlan = nconc(newnode->plan.subPlan, - pull_subplans(newnode->resconstantqual)); + /* subPlan list must point to subplans in the new subtree, not the old */ + FIX_SUBPLAN_LINKS(plan.subPlan, resconstantqual); return newnode; } -/* ---------------- - * _copyAppend - * ---------------- +/* + * _copyAppend */ static Append * _copyAppend(Append *from) @@ -170,30 +192,29 @@ _copyAppend(Append *from) /* * copy remainder of node */ - Node_Copy(from, newnode, appendplans); - newnode->isTarget = from->isTarget; + COPY_NODE_FIELD(appendplans); + COPY_SCALAR_FIELD(isTarget); return newnode; } -/* ---------------- - * CopyScanFields +/* + * 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(Scan *from, Scan *newnode) { - newnode->scanrelid = from->scanrelid; - return; + CopyPlanFields((Plan *) from, (Plan *) newnode); + + COPY_SCALAR_FIELD(scanrelid); } -/* ---------------- - * _copyScan - * ---------------- +/* + * _copyScan */ static Scan * _copyScan(Scan *from) @@ -203,15 +224,13 @@ _copyScan(Scan *from) /* * copy node superclass fields */ - CopyPlanFields((Plan *) from, (Plan *) newnode); CopyScanFields((Scan *) from, (Scan *) newnode); return newnode; } -/* ---------------- - * _copySeqScan - * ---------------- +/* + * _copySeqScan */ static SeqScan * _copySeqScan(SeqScan *from) @@ -221,15 +240,13 @@ _copySeqScan(SeqScan *from) /* * copy node superclass fields */ - CopyPlanFields((Plan *) from, (Plan *) newnode); CopyScanFields((Scan *) from, (Scan *) newnode); return newnode; } -/* ---------------- - * _copyIndexScan - * ---------------- +/* + * _copyIndexScan */ static IndexScan * _copyIndexScan(IndexScan *from) @@ -239,34 +256,25 @@ _copyIndexScan(IndexScan *from) /* * copy node superclass fields */ - CopyPlanFields((Plan *) from, (Plan *) newnode); CopyScanFields((Scan *) from, (Scan *) newnode); /* * copy remainder of node */ - newnode->indxid = listCopy(from->indxid); - Node_Copy(from, newnode, indxqual); - Node_Copy(from, newnode, indxqualorig); - newnode->indxorderdir = from->indxorderdir; + COPY_INTLIST_FIELD(indxid); + COPY_NODE_FIELD(indxqual); + COPY_NODE_FIELD(indxqualorig); + COPY_SCALAR_FIELD(indxorderdir); - /* - * We must add subplans in index quals to the new plan's subPlan list - */ - if (from->scan.plan.subPlan != NIL) - { - newnode->scan.plan.subPlan = nconc(newnode->scan.plan.subPlan, - pull_subplans((Node *) newnode->indxqual)); - newnode->scan.plan.subPlan = nconc(newnode->scan.plan.subPlan, - pull_subplans((Node *) newnode->indxqualorig)); - } + /* subPlan list must point to subplans in the new subtree, not the old */ + FIX_SUBPLAN_LINKS(scan.plan.subPlan, indxqual); + FIX_SUBPLAN_LINKS(scan.plan.subPlan, indxqualorig); return newnode; } -/* ---------------- - * _copyTidScan - * ---------------- +/* + * _copyTidScan */ static TidScan * _copyTidScan(TidScan *from) @@ -276,21 +284,22 @@ _copyTidScan(TidScan *from) /* * copy node superclass fields */ - CopyPlanFields((Plan *) from, (Plan *) newnode); CopyScanFields((Scan *) from, (Scan *) newnode); /* * copy remainder of node */ - newnode->needRescan = from->needRescan; - Node_Copy(from, newnode, tideval); + COPY_SCALAR_FIELD(needRescan); + COPY_NODE_FIELD(tideval); + + /* subPlan list must point to subplans in the new subtree, not the old */ + FIX_SUBPLAN_LINKS(scan.plan.subPlan, tideval); return newnode; } -/* ---------------- - * _copySubqueryScan - * ---------------- +/* + * _copySubqueryScan */ static SubqueryScan * _copySubqueryScan(SubqueryScan *from) @@ -300,20 +309,18 @@ _copySubqueryScan(SubqueryScan *from) /* * copy node superclass fields */ - CopyPlanFields((Plan *) from, (Plan *) newnode); CopyScanFields((Scan *) from, (Scan *) newnode); /* * copy remainder of node */ - Node_Copy(from, newnode, subplan); + COPY_NODE_FIELD(subplan); return newnode; } -/* ---------------- - * _copyFunctionScan - * ---------------- +/* + * _copyFunctionScan */ static FunctionScan * _copyFunctionScan(FunctionScan *from) @@ -323,34 +330,32 @@ _copyFunctionScan(FunctionScan *from) /* * copy node superclass fields */ - CopyPlanFields((Plan *) from, (Plan *) newnode); CopyScanFields((Scan *) from, (Scan *) newnode); return newnode; } -/* ---------------- - * CopyJoinFields +/* + * 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(Join *from, Join *newnode) { - newnode->jointype = from->jointype; - Node_Copy(from, newnode, joinqual); + CopyPlanFields((Plan *) from, (Plan *) newnode); + + COPY_SCALAR_FIELD(jointype); + COPY_NODE_FIELD(joinqual); + /* subPlan list must point to subplans in the new subtree, not the old */ - if (from->plan.subPlan != NIL) - newnode->plan.subPlan = nconc(newnode->plan.subPlan, - pull_subplans((Node *) newnode->joinqual)); + FIX_SUBPLAN_LINKS(plan.subPlan, joinqual); } -/* ---------------- - * _copyJoin - * ---------------- +/* + * _copyJoin */ static Join * _copyJoin(Join *from) @@ -360,16 +365,14 @@ _copyJoin(Join *from) /* * copy node superclass fields */ - CopyPlanFields((Plan *) from, (Plan *) newnode); CopyJoinFields(from, newnode); return newnode; } -/* ---------------- - * _copyNestLoop - * ---------------- +/* + * _copyNestLoop */ static NestLoop * _copyNestLoop(NestLoop *from) @@ -379,16 +382,14 @@ _copyNestLoop(NestLoop *from) /* * copy node superclass fields */ - CopyPlanFields((Plan *) from, (Plan *) newnode); CopyJoinFields((Join *) from, (Join *) newnode); return newnode; } -/* ---------------- - * _copyMergeJoin - * ---------------- +/* + * _copyMergeJoin */ static MergeJoin * _copyMergeJoin(MergeJoin *from) @@ -398,27 +399,21 @@ _copyMergeJoin(MergeJoin *from) /* * copy node superclass fields */ - CopyPlanFields((Plan *) from, (Plan *) newnode); CopyJoinFields((Join *) from, (Join *) newnode); /* * copy remainder of node */ - Node_Copy(from, newnode, mergeclauses); + COPY_NODE_FIELD(mergeclauses); - /* - * We must add subplans in mergeclauses to the new plan's subPlan list - */ - if (from->join.plan.subPlan != NIL) - newnode->join.plan.subPlan = nconc(newnode->join.plan.subPlan, - pull_subplans((Node *) newnode->mergeclauses)); + /* subPlan list must point to subplans in the new subtree, not the old */ + FIX_SUBPLAN_LINKS(join.plan.subPlan, mergeclauses); return newnode; } -/* ---------------- - * _copyHashJoin - * ---------------- +/* + * _copyHashJoin */ static HashJoin * _copyHashJoin(HashJoin *from) @@ -428,29 +423,23 @@ _copyHashJoin(HashJoin *from) /* * copy node superclass fields */ - CopyPlanFields((Plan *) from, (Plan *) newnode); CopyJoinFields((Join *) from, (Join *) newnode); /* * copy remainder of node */ - Node_Copy(from, newnode, hashclauses); - newnode->hashjoinop = from->hashjoinop; + COPY_NODE_FIELD(hashclauses); + COPY_SCALAR_FIELD(hashjoinop); - /* - * We must add subplans in hashclauses to the new plan's subPlan list - */ - if (from->join.plan.subPlan != NIL) - newnode->join.plan.subPlan = nconc(newnode->join.plan.subPlan, - pull_subplans((Node *) newnode->hashclauses)); + /* subPlan list must point to subplans in the new subtree, not the old */ + FIX_SUBPLAN_LINKS(join.plan.subPlan, hashclauses); return newnode; } -/* ---------------- - * _copyMaterial - * ---------------- +/* + * _copyMaterial */ static Material * _copyMaterial(Material *from) @@ -466,9 +455,8 @@ _copyMaterial(Material *from) } -/* ---------------- - * _copySort - * ---------------- +/* + * _copySort */ static Sort * _copySort(Sort *from) @@ -480,15 +468,14 @@ _copySort(Sort *from) */ CopyPlanFields((Plan *) from, (Plan *) newnode); - newnode->keycount = from->keycount; + COPY_SCALAR_FIELD(keycount); return newnode; } -/* ---------------- - * _copyGroup - * ---------------- +/* + * _copyGroup */ static Group * _copyGroup(Group *from) @@ -497,17 +484,14 @@ _copyGroup(Group *from) CopyPlanFields((Plan *) from, (Plan *) newnode); - newnode->numCols = from->numCols; - newnode->grpColIdx = palloc(from->numCols * sizeof(AttrNumber)); - memcpy(newnode->grpColIdx, from->grpColIdx, - from->numCols * sizeof(AttrNumber)); + COPY_SCALAR_FIELD(numCols); + COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber)); return newnode; } -/* --------------- - * _copyAgg - * -------------- +/* + * _copyAgg */ static Agg * _copyAgg(Agg *from) @@ -516,37 +500,17 @@ _copyAgg(Agg *from) CopyPlanFields((Plan *) from, (Plan *) newnode); - newnode->aggstrategy = from->aggstrategy; - newnode->numCols = from->numCols; + COPY_SCALAR_FIELD(aggstrategy); + COPY_SCALAR_FIELD(numCols); if (from->numCols > 0) - { - newnode->grpColIdx = palloc(from->numCols * sizeof(AttrNumber)); - memcpy(newnode->grpColIdx, from->grpColIdx, - from->numCols * sizeof(AttrNumber)); - } - newnode->numGroups = from->numGroups; - - return newnode; -} - -/* --------------- - * _copyGroupClause - * -------------- - */ -static GroupClause * -_copyGroupClause(GroupClause *from) -{ - GroupClause *newnode = makeNode(GroupClause); - - newnode->tleSortGroupRef = from->tleSortGroupRef; - newnode->sortop = from->sortop; + COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber)); + COPY_SCALAR_FIELD(numGroups); return newnode; } -/* ---------------- - * _copyUnique - * ---------------- +/* + * _copyUnique */ static Unique * _copyUnique(Unique *from) @@ -561,16 +525,14 @@ _copyUnique(Unique *from) /* * copy remainder of node */ - newnode->numCols = from->numCols; - newnode->uniqColIdx = palloc(from->numCols * sizeof(AttrNumber)); - memcpy(newnode->uniqColIdx, from->uniqColIdx, from->numCols * sizeof(AttrNumber)); + COPY_SCALAR_FIELD(numCols); + COPY_POINTER_FIELD(uniqColIdx, from->numCols * sizeof(AttrNumber)); return newnode; } -/* ---------------- - * _copySetOp - * ---------------- +/* + * _copySetOp */ static SetOp * _copySetOp(SetOp *from) @@ -585,18 +547,16 @@ _copySetOp(SetOp *from) /* * copy remainder of node */ - newnode->cmd = from->cmd; - newnode->numCols = from->numCols; - newnode->dupColIdx = palloc(from->numCols * sizeof(AttrNumber)); - memcpy(newnode->dupColIdx, from->dupColIdx, from->numCols * sizeof(AttrNumber)); - newnode->flagColIdx = from->flagColIdx; + COPY_SCALAR_FIELD(cmd); + COPY_SCALAR_FIELD(numCols); + COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber)); + COPY_SCALAR_FIELD(flagColIdx); return newnode; } -/* ---------------- - * _copyLimit - * ---------------- +/* + * _copyLimit */ static Limit * _copyLimit(Limit *from) @@ -611,15 +571,14 @@ _copyLimit(Limit *from) /* * copy remainder of node */ - Node_Copy(from, newnode, limitOffset); - Node_Copy(from, newnode, limitCount); + COPY_NODE_FIELD(limitOffset); + COPY_NODE_FIELD(limitCount); return newnode; } -/* ---------------- - * _copyHash - * ---------------- +/* + * _copyHash */ static Hash * _copyHash(Hash *from) @@ -634,7 +593,9 @@ _copyHash(Hash *from) /* * copy remainder of node */ - Node_Copy(from, newnode, hashkey); + COPY_NODE_FIELD(hashkey); + + /* XXX could the hashkey contain subplans? Not at present... */ return newnode; } @@ -644,12 +605,12 @@ _copySubPlan(SubPlan *from) { SubPlan *newnode = makeNode(SubPlan); - Node_Copy(from, newnode, plan); - newnode->plan_id = from->plan_id; - Node_Copy(from, newnode, rtable); - newnode->setParam = listCopy(from->setParam); - newnode->parParam = listCopy(from->parParam); - Node_Copy(from, newnode, sublink); + COPY_NODE_FIELD(plan); + COPY_SCALAR_FIELD(plan_id); + COPY_NODE_FIELD(rtable); + COPY_INTLIST_FIELD(setParam); + COPY_INTLIST_FIELD(parParam); + COPY_NODE_FIELD(sublink); /* do not copy execution state */ newnode->needShutdown = false; @@ -663,24 +624,22 @@ _copySubPlan(SubPlan *from) * **************************************************************** */ -/* ---------------- - * _copyResdom - * ---------------- +/* + * _copyResdom */ static Resdom * _copyResdom(Resdom *from) { Resdom *newnode = makeNode(Resdom); - newnode->resno = from->resno; - newnode->restype = from->restype; - newnode->restypmod = from->restypmod; - if (from->resname != NULL) - newnode->resname = pstrdup(from->resname); - newnode->ressortgroupref = from->ressortgroupref; - newnode->reskey = from->reskey; - newnode->reskeyop = from->reskeyop; - newnode->resjunk = from->resjunk; + COPY_SCALAR_FIELD(resno); + COPY_SCALAR_FIELD(restype); + COPY_SCALAR_FIELD(restypmod); + COPY_STRING_FIELD(resname); + COPY_SCALAR_FIELD(ressortgroupref); + COPY_SCALAR_FIELD(reskey); + COPY_SCALAR_FIELD(reskeyop); + COPY_SCALAR_FIELD(resjunk); return newnode; } @@ -690,112 +649,105 @@ _copyFjoin(Fjoin *from) { Fjoin *newnode = makeNode(Fjoin); - /* - * copy node superclass fields - */ + COPY_SCALAR_FIELD(fj_initialized); + COPY_SCALAR_FIELD(fj_nNodes); + COPY_NODE_FIELD(fj_innerNode); + COPY_POINTER_FIELD(fj_results, from->fj_nNodes * sizeof(Datum)); + COPY_POINTER_FIELD(fj_alwaysDone, from->fj_nNodes * sizeof(bool)); - newnode->fj_initialized = from->fj_initialized; - newnode->fj_nNodes = from->fj_nNodes; + return newnode; +} - Node_Copy(from, newnode, fj_innerNode); +static Alias * +_copyAlias(Alias *from) +{ + Alias *newnode = makeNode(Alias); - newnode->fj_results = (DatumPtr) - palloc((from->fj_nNodes) * sizeof(Datum)); - memmove(from->fj_results, - newnode->fj_results, - (from->fj_nNodes) * sizeof(Datum)); + COPY_STRING_FIELD(aliasname); + COPY_NODE_FIELD(colnames); - newnode->fj_alwaysDone = (BoolPtr) - palloc((from->fj_nNodes) * sizeof(bool)); - memmove(from->fj_alwaysDone, - newnode->fj_alwaysDone, - (from->fj_nNodes) * sizeof(bool)); + return newnode; +} +static RangeVar * +_copyRangeVar(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(istemp); + COPY_NODE_FIELD(alias); return newnode; } -/* ---------------- - * _copyExpr - * ---------------- +/* + * _copyExpr */ static Expr * _copyExpr(Expr *from) { Expr *newnode = makeNode(Expr); - /* - * copy node superclass fields - */ - newnode->typeOid = from->typeOid; - newnode->opType = from->opType; - - Node_Copy(from, newnode, oper); - Node_Copy(from, newnode, args); + COPY_SCALAR_FIELD(typeOid); + COPY_SCALAR_FIELD(opType); + COPY_NODE_FIELD(oper); + COPY_NODE_FIELD(args); return newnode; } -/* ---------------- - * _copyVar - * ---------------- +/* + * _copyVar */ static Var * _copyVar(Var *from) { Var *newnode = makeNode(Var); - /* - * copy remainder of node - */ - newnode->varno = from->varno; - newnode->varattno = from->varattno; - newnode->vartype = from->vartype; - newnode->vartypmod = from->vartypmod; - newnode->varlevelsup = from->varlevelsup; - - newnode->varnoold = from->varnoold; - newnode->varoattno = from->varoattno; + COPY_SCALAR_FIELD(varno); + COPY_SCALAR_FIELD(varattno); + COPY_SCALAR_FIELD(vartype); + COPY_SCALAR_FIELD(vartypmod); + COPY_SCALAR_FIELD(varlevelsup); + COPY_SCALAR_FIELD(varnoold); + COPY_SCALAR_FIELD(varoattno); return newnode; } -/* ---------------- - * _copyOper - * ---------------- +/* + * _copyOper */ static Oper * _copyOper(Oper *from) { Oper *newnode = makeNode(Oper); - /* - * copy remainder of node - */ - newnode->opno = from->opno; - newnode->opid = from->opid; - newnode->opresulttype = from->opresulttype; - newnode->opretset = from->opretset; + COPY_SCALAR_FIELD(opno); + COPY_SCALAR_FIELD(opid); + COPY_SCALAR_FIELD(opresulttype); + COPY_SCALAR_FIELD(opretset); + /* Do not copy the run-time state, if any */ newnode->op_fcache = NULL; return newnode; } -/* ---------------- - * _copyConst - * ---------------- +/* + * _copyConst */ static Const * _copyConst(Const *from) { Const *newnode = makeNode(Const); - /* - * copy remainder of node - */ - newnode->consttype = from->consttype; - newnode->constlen = from->constlen; + COPY_SCALAR_FIELD(consttype); + COPY_SCALAR_FIELD(constlen); if (from->constbyval || from->constisnull) { @@ -808,141 +760,119 @@ _copyConst(Const *from) else { /* - * not passed by value. We need a palloc'd copy. + * passed by reference. We need a palloc'd copy. */ newnode->constvalue = datumCopy(from->constvalue, from->constbyval, from->constlen); } - newnode->constisnull = from->constisnull; - newnode->constbyval = from->constbyval; - newnode->constisset = from->constisset; - newnode->constiscast = from->constiscast; + COPY_SCALAR_FIELD(constisnull); + COPY_SCALAR_FIELD(constbyval); + COPY_SCALAR_FIELD(constisset); + COPY_SCALAR_FIELD(constiscast); return newnode; } -/* ---------------- - * _copyParam - * ---------------- +/* + * _copyParam */ static Param * _copyParam(Param *from) { Param *newnode = makeNode(Param); - /* - * copy remainder of node - */ - newnode->paramkind = from->paramkind; - newnode->paramid = from->paramid; - - if (from->paramname != NULL) - newnode->paramname = pstrdup(from->paramname); - newnode->paramtype = from->paramtype; + COPY_SCALAR_FIELD(paramkind); + COPY_SCALAR_FIELD(paramid); + COPY_STRING_FIELD(paramname); + COPY_SCALAR_FIELD(paramtype); return newnode; } -/* ---------------- - * _copyFunc - * ---------------- +/* + * _copyFunc */ static Func * _copyFunc(Func *from) { Func *newnode = makeNode(Func); - /* - * copy remainder of node - */ - newnode->funcid = from->funcid; - newnode->funcresulttype = from->funcresulttype; - newnode->funcretset = from->funcretset; - newnode->funcformat = from->funcformat; + COPY_SCALAR_FIELD(funcid); + COPY_SCALAR_FIELD(funcresulttype); + COPY_SCALAR_FIELD(funcretset); + COPY_SCALAR_FIELD(funcformat); + /* Do not copy the run-time state, if any */ newnode->func_fcache = NULL; return newnode; } -/* ---------------- - * _copyAggref - * ---------------- +/* + * _copyAggref */ static Aggref * _copyAggref(Aggref *from) { Aggref *newnode = makeNode(Aggref); - newnode->aggfnoid = from->aggfnoid; - newnode->aggtype = from->aggtype; - Node_Copy(from, newnode, target); - newnode->aggstar = from->aggstar; - newnode->aggdistinct = from->aggdistinct; - newnode->aggno = from->aggno; /* probably not needed */ + COPY_SCALAR_FIELD(aggfnoid); + COPY_SCALAR_FIELD(aggtype); + COPY_NODE_FIELD(target); + COPY_SCALAR_FIELD(aggstar); + COPY_SCALAR_FIELD(aggdistinct); + COPY_SCALAR_FIELD(aggno); /* probably not necessary */ return newnode; } -/* ---------------- - * _copySubLink - * ---------------- +/* + * _copySubLink */ static SubLink * _copySubLink(SubLink *from) { SubLink *newnode = makeNode(SubLink); - /* - * copy remainder of node - */ - newnode->subLinkType = from->subLinkType; - newnode->useor = from->useor; - Node_Copy(from, newnode, lefthand); - Node_Copy(from, newnode, oper); - Node_Copy(from, newnode, subselect); + COPY_SCALAR_FIELD(subLinkType); + COPY_SCALAR_FIELD(useor); + COPY_NODE_FIELD(lefthand); + COPY_NODE_FIELD(oper); + COPY_NODE_FIELD(subselect); return newnode; } -/* ---------------- - * _copyFieldSelect - * ---------------- +/* + * _copyFieldSelect */ static FieldSelect * _copyFieldSelect(FieldSelect *from) { FieldSelect *newnode = makeNode(FieldSelect); - /* - * copy remainder of node - */ - Node_Copy(from, newnode, arg); - newnode->fieldnum = from->fieldnum; - newnode->resulttype = from->resulttype; - newnode->resulttypmod = from->resulttypmod; + COPY_NODE_FIELD(arg); + COPY_SCALAR_FIELD(fieldnum); + COPY_SCALAR_FIELD(resulttype); + COPY_SCALAR_FIELD(resulttypmod); return newnode; } -/* ---------------- - * _copyRelabelType - * ---------------- +/* + * _copyRelabelType */ static RelabelType * _copyRelabelType(RelabelType *from) { RelabelType *newnode = makeNode(RelabelType); - /* - * copy remainder of node - */ - Node_Copy(from, newnode, arg); - newnode->resulttype = from->resulttype; - newnode->resulttypmod = from->resulttypmod; - newnode->relabelformat = from->relabelformat; + COPY_NODE_FIELD(arg); + COPY_SCALAR_FIELD(resulttype); + COPY_SCALAR_FIELD(resulttypmod); + COPY_SCALAR_FIELD(relabelformat); return newnode; } @@ -952,18 +882,7 @@ _copyRangeTblRef(RangeTblRef *from) { RangeTblRef *newnode = makeNode(RangeTblRef); - newnode->rtindex = from->rtindex; - - return newnode; -} - -static FromExpr * -_copyFromExpr(FromExpr *from) -{ - FromExpr *newnode = makeNode(FromExpr); - - Node_Copy(from, newnode, fromlist); - Node_Copy(from, newnode, quals); + COPY_SCALAR_FIELD(rtindex); return newnode; } @@ -973,114 +892,25 @@ _copyJoinExpr(JoinExpr *from) { JoinExpr *newnode = makeNode(JoinExpr); - newnode->jointype = from->jointype; - newnode->isNatural = from->isNatural; - Node_Copy(from, newnode, larg); - Node_Copy(from, newnode, rarg); - Node_Copy(from, newnode, using); - Node_Copy(from, newnode, quals); - Node_Copy(from, newnode, alias); - newnode->rtindex = from->rtindex; - - return newnode; -} - -static CaseExpr * -_copyCaseExpr(CaseExpr *from) -{ - CaseExpr *newnode = makeNode(CaseExpr); - - /* - * copy remainder of node - */ - newnode->casetype = from->casetype; - - Node_Copy(from, newnode, arg); - Node_Copy(from, newnode, args); - Node_Copy(from, newnode, defresult); - - return newnode; -} - -static CaseWhen * -_copyCaseWhen(CaseWhen *from) -{ - CaseWhen *newnode = makeNode(CaseWhen); - - /* - * copy remainder of node - */ - Node_Copy(from, newnode, expr); - Node_Copy(from, newnode, result); + COPY_SCALAR_FIELD(jointype); + COPY_SCALAR_FIELD(isNatural); + COPY_NODE_FIELD(larg); + COPY_NODE_FIELD(rarg); + COPY_NODE_FIELD(using); + COPY_NODE_FIELD(quals); + COPY_NODE_FIELD(alias); + COPY_SCALAR_FIELD(rtindex); return newnode; } -static NullTest * -_copyNullTest(NullTest *from) -{ - NullTest *newnode = makeNode(NullTest); - - /* - * copy remainder of node - */ - Node_Copy(from, newnode, arg); - newnode->nulltesttype = from->nulltesttype; - - return newnode; -} - -static BooleanTest * -_copyBooleanTest(BooleanTest *from) -{ - BooleanTest *newnode = makeNode(BooleanTest); - - /* - * copy remainder of node - */ - Node_Copy(from, newnode, arg); - newnode->booltesttype = from->booltesttype; - - return newnode; -} - -static ConstraintTest * -_copyConstraintTest(ConstraintTest *from) -{ - ConstraintTest *newnode = makeNode(ConstraintTest); - - /* - * copy remainder of node - */ - Node_Copy(from, newnode, arg); - newnode->testtype = from->testtype; - if (from->name) - newnode->name = pstrdup(from->name); - if (from->domname) - newnode->domname = pstrdup(from->domname); - Node_Copy(from, newnode, check_expr); - - return newnode; -} - -static ConstraintTestValue * -_copyConstraintTestValue(ConstraintTestValue *from) +static FromExpr * +_copyFromExpr(FromExpr *from) { - ConstraintTestValue *newnode = makeNode(ConstraintTestValue); - - /* - * copy remainder of node - */ - newnode->typeId = from->typeId; - newnode->typeMod = from->typeMod; - - return newnode; -} + FromExpr *newnode = makeNode(FromExpr); -static DomainConstraintValue * -_copyDomainConstraintValue(DomainConstraintValue *from) -{ - DomainConstraintValue *newnode = makeNode(DomainConstraintValue); + COPY_NODE_FIELD(fromlist); + COPY_NODE_FIELD(quals); return newnode; } @@ -1090,130 +920,112 @@ _copyArrayRef(ArrayRef *from) { ArrayRef *newnode = makeNode(ArrayRef); - /* - * copy remainder of node - */ - newnode->refrestype = from->refrestype; - newnode->refattrlength = from->refattrlength; - newnode->refelemlength = from->refelemlength; - newnode->refelembyval = from->refelembyval; - newnode->refelemalign = from->refelemalign; - - Node_Copy(from, newnode, refupperindexpr); - Node_Copy(from, newnode, reflowerindexpr); - Node_Copy(from, newnode, refexpr); - Node_Copy(from, newnode, refassgnexpr); + COPY_SCALAR_FIELD(refrestype); + COPY_SCALAR_FIELD(refattrlength); + COPY_SCALAR_FIELD(refelemlength); + COPY_SCALAR_FIELD(refelembyval); + COPY_SCALAR_FIELD(refelemalign); + COPY_NODE_FIELD(refupperindexpr); + COPY_NODE_FIELD(reflowerindexpr); + COPY_NODE_FIELD(refexpr); + COPY_NODE_FIELD(refassgnexpr); return newnode; } /* **************************************************************** * relation.h copy functions + * + * XXX the code to copy RelOptInfo and Path nodes is really completely bogus, + * because it makes no attempt to deal with multiple links from RelOptInfo + * to Paths, nor with back-links from Paths to their parent RelOptInfo. + * Currently, since we never actually try to copy a RelOptInfo, this is okay. * **************************************************************** */ -/* ---------------- - * _copyRelOptInfo - * ---------------- +/* + * _copyRelOptInfo */ static RelOptInfo * _copyRelOptInfo(RelOptInfo *from) { RelOptInfo *newnode = makeNode(RelOptInfo); - newnode->reloptkind = from->reloptkind; - - newnode->relids = listCopy(from->relids); - - newnode->rows = from->rows; - newnode->width = from->width; - - Node_Copy(from, newnode, targetlist); - Node_Copy(from, newnode, pathlist); + COPY_SCALAR_FIELD(reloptkind); + COPY_INTLIST_FIELD(relids); + COPY_SCALAR_FIELD(rows); + COPY_SCALAR_FIELD(width); + COPY_NODE_FIELD(targetlist); + COPY_NODE_FIELD(pathlist); /* XXX cheapest-path fields should point to members of pathlist? */ - Node_Copy(from, newnode, cheapest_startup_path); - Node_Copy(from, newnode, cheapest_total_path); - newnode->pruneable = from->pruneable; - - newnode->rtekind = from->rtekind; - Node_Copy(from, newnode, indexlist); - newnode->pages = from->pages; - newnode->tuples = from->tuples; - Node_Copy(from, newnode, subplan); - - newnode->joinrti = from->joinrti; - newnode->joinrteids = listCopy(from->joinrteids); - - Node_Copy(from, newnode, baserestrictinfo); - newnode->baserestrictcost = from->baserestrictcost; - newnode->outerjoinset = listCopy(from->outerjoinset); - Node_Copy(from, newnode, joininfo); - - newnode->index_outer_relids = listCopy(from->index_outer_relids); - Node_Copy(from, newnode, index_inner_paths); + COPY_NODE_FIELD(cheapest_startup_path); + COPY_NODE_FIELD(cheapest_total_path); + COPY_SCALAR_FIELD(pruneable); + COPY_SCALAR_FIELD(rtekind); + COPY_NODE_FIELD(indexlist); + COPY_SCALAR_FIELD(pages); + COPY_SCALAR_FIELD(tuples); + COPY_NODE_FIELD(subplan); + COPY_SCALAR_FIELD(joinrti); + COPY_INTLIST_FIELD(joinrteids); + COPY_NODE_FIELD(baserestrictinfo); + COPY_SCALAR_FIELD(baserestrictcost); + COPY_INTLIST_FIELD(outerjoinset); + COPY_NODE_FIELD(joininfo); + COPY_INTLIST_FIELD(index_outer_relids); + COPY_NODE_FIELD(index_inner_paths); return newnode; } -/* ---------------- - * _copyIndexOptInfo - * ---------------- +/* + * _copyIndexOptInfo */ static IndexOptInfo * _copyIndexOptInfo(IndexOptInfo *from) { IndexOptInfo *newnode = makeNode(IndexOptInfo); - Size len; - - newnode->indexoid = from->indexoid; - newnode->pages = from->pages; - newnode->tuples = from->tuples; - newnode->ncolumns = from->ncolumns; - newnode->nkeys = from->nkeys; + COPY_SCALAR_FIELD(indexoid); + COPY_SCALAR_FIELD(pages); + COPY_SCALAR_FIELD(tuples); + COPY_SCALAR_FIELD(ncolumns); + COPY_SCALAR_FIELD(nkeys); if (from->classlist) { /* copy the trailing zero too */ - len = (from->ncolumns + 1) * sizeof(Oid); - newnode->classlist = (Oid *) palloc(len); - memcpy(newnode->classlist, from->classlist, len); + COPY_POINTER_FIELD(classlist, (from->ncolumns + 1) * sizeof(Oid)); } if (from->indexkeys) { /* copy the trailing zero too */ - len = (from->nkeys + 1) * sizeof(int); - newnode->indexkeys = (int *) palloc(len); - memcpy(newnode->indexkeys, from->indexkeys, len); + COPY_POINTER_FIELD(indexkeys, (from->nkeys + 1) * sizeof(int)); } if (from->ordering) { /* copy the trailing zero too */ - len = (from->ncolumns + 1) * sizeof(Oid); - newnode->ordering = (Oid *) palloc(len); - memcpy(newnode->ordering, from->ordering, len); + COPY_POINTER_FIELD(ordering, (from->ncolumns + 1) * sizeof(Oid)); } - newnode->relam = from->relam; - newnode->amcostestimate = from->amcostestimate; - newnode->indproc = from->indproc; - Node_Copy(from, newnode, indpred); - newnode->unique = from->unique; - - newnode->outer_relids = listCopy(from->outer_relids); - Node_Copy(from, newnode, inner_paths); + COPY_SCALAR_FIELD(relam); + COPY_SCALAR_FIELD(amcostestimate); + COPY_SCALAR_FIELD(indproc); + COPY_NODE_FIELD(indpred); + COPY_SCALAR_FIELD(unique); + COPY_INTLIST_FIELD(outer_relids); + COPY_NODE_FIELD(inner_paths); return newnode; } -/* ---------------- - * CopyPathFields +/* + * CopyPathFields * * This function copies the fields of the Path node. It is used by * all the copy functions for classes which inherit from Path. - * ---------------- */ static void CopyPathFields(Path *from, Path *newnode) @@ -1221,21 +1033,18 @@ CopyPathFields(Path *from, Path *newnode) /* * Modify the next line, since it causes the copying to cycle (i.e. * the parent points right back here! -- JMH, 7/7/92. Old version: - * Node_Copy(from, newnode, parent); + * COPY_NODE_FIELD(parent); */ - newnode->parent = from->parent; - - newnode->startup_cost = from->startup_cost; - newnode->total_cost = from->total_cost; + COPY_SCALAR_FIELD(parent); - newnode->pathtype = from->pathtype; - - Node_Copy(from, newnode, pathkeys); + COPY_SCALAR_FIELD(startup_cost); + COPY_SCALAR_FIELD(total_cost); + COPY_SCALAR_FIELD(pathtype); + COPY_NODE_FIELD(pathkeys); } -/* ---------------- - * _copyPath - * ---------------- +/* + * _copyPath */ static Path * _copyPath(Path *from) @@ -1247,9 +1056,8 @@ _copyPath(Path *from) return newnode; } -/* ---------------- - * _copyIndexPath - * ---------------- +/* + * _copyIndexPath */ static IndexPath * _copyIndexPath(IndexPath *from) @@ -1257,24 +1065,23 @@ _copyIndexPath(IndexPath *from) IndexPath *newnode = makeNode(IndexPath); /* - * copy the node superclass fields + * copy node superclass fields */ CopyPathFields((Path *) from, (Path *) newnode); /* * copy remainder of node */ - Node_Copy(from, newnode, indexinfo); - Node_Copy(from, newnode, indexqual); - newnode->indexscandir = from->indexscandir; - newnode->rows = from->rows; + COPY_NODE_FIELD(indexinfo); + COPY_NODE_FIELD(indexqual); + COPY_SCALAR_FIELD(indexscandir); + COPY_SCALAR_FIELD(rows); return newnode; } -/* ---------------- - * _copyTidPath - * ---------------- +/* + * _copyTidPath */ static TidPath * _copyTidPath(TidPath *from) @@ -1282,22 +1089,21 @@ _copyTidPath(TidPath *from) TidPath *newnode = makeNode(TidPath); /* - * copy the node superclass fields + * copy node superclass fields */ CopyPathFields((Path *) from, (Path *) newnode); /* * copy remainder of node */ - Node_Copy(from, newnode, tideval); - newnode->unjoined_relids = listCopy(from->unjoined_relids); + COPY_NODE_FIELD(tideval); + COPY_INTLIST_FIELD(unjoined_relids); return newnode; } -/* ---------------- - * _copyAppendPath - * ---------------- +/* + * _copyAppendPath */ static AppendPath * _copyAppendPath(AppendPath *from) @@ -1305,21 +1111,20 @@ _copyAppendPath(AppendPath *from) AppendPath *newnode = makeNode(AppendPath); /* - * copy the node superclass fields + * copy node superclass fields */ CopyPathFields((Path *) from, (Path *) newnode); /* * copy remainder of node */ - Node_Copy(from, newnode, subpaths); + COPY_NODE_FIELD(subpaths); return newnode; } -/* ---------------- - * _copyResultPath - * ---------------- +/* + * _copyResultPath */ static ResultPath * _copyResultPath(ResultPath *from) @@ -1327,38 +1132,38 @@ _copyResultPath(ResultPath *from) ResultPath *newnode = makeNode(ResultPath); /* - * copy the node superclass fields + * copy node superclass fields */ CopyPathFields((Path *) from, (Path *) newnode); /* * copy remainder of node */ - Node_Copy(from, newnode, subpath); - Node_Copy(from, newnode, constantqual); + COPY_NODE_FIELD(subpath); + COPY_NODE_FIELD(constantqual); return newnode; } -/* ---------------- - * CopyJoinPathFields +/* + * CopyJoinPathFields * * This function copies the fields of the JoinPath node. It is used by * all the copy functions for classes which inherit from JoinPath. - * ---------------- */ static void CopyJoinPathFields(JoinPath *from, JoinPath *newnode) { - newnode->jointype = from->jointype; - Node_Copy(from, newnode, outerjoinpath); - Node_Copy(from, newnode, innerjoinpath); - Node_Copy(from, newnode, joinrestrictinfo); + CopyPathFields((Path *) from, (Path *) newnode); + + COPY_SCALAR_FIELD(jointype); + COPY_NODE_FIELD(outerjoinpath); + COPY_NODE_FIELD(innerjoinpath); + COPY_NODE_FIELD(joinrestrictinfo); } -/* ---------------- - * _copyNestPath - * ---------------- +/* + * _copyNestPath */ static NestPath * _copyNestPath(NestPath *from) @@ -1366,17 +1171,15 @@ _copyNestPath(NestPath *from) NestPath *newnode = makeNode(NestPath); /* - * copy the node superclass fields + * copy node superclass fields */ - CopyPathFields((Path *) from, (Path *) newnode); CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode); return newnode; } -/* ---------------- - * _copyMergePath - * ---------------- +/* + * _copyMergePath */ static MergePath * _copyMergePath(MergePath *from) @@ -1384,24 +1187,22 @@ _copyMergePath(MergePath *from) MergePath *newnode = makeNode(MergePath); /* - * copy the node superclass fields + * copy node superclass fields */ - CopyPathFields((Path *) from, (Path *) newnode); CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode); /* - * copy the remainder of the node + * copy remainder of node */ - Node_Copy(from, newnode, path_mergeclauses); - Node_Copy(from, newnode, outersortkeys); - Node_Copy(from, newnode, innersortkeys); + COPY_NODE_FIELD(path_mergeclauses); + COPY_NODE_FIELD(outersortkeys); + COPY_NODE_FIELD(innersortkeys); return newnode; } -/* ---------------- - * _copyHashPath - * ---------------- +/* + * _copyHashPath */ static HashPath * _copyHashPath(HashPath *from) @@ -1409,57 +1210,48 @@ _copyHashPath(HashPath *from) HashPath *newnode = makeNode(HashPath); /* - * copy the node superclass fields + * copy node superclass fields */ - CopyPathFields((Path *) from, (Path *) newnode); CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode); /* * copy remainder of node */ - Node_Copy(from, newnode, path_hashclauses); + COPY_NODE_FIELD(path_hashclauses); return newnode; } -/* ---------------- - * _copyPathKeyItem - * ---------------- +/* + * _copyPathKeyItem */ static PathKeyItem * _copyPathKeyItem(PathKeyItem *from) { PathKeyItem *newnode = makeNode(PathKeyItem); - /* - * copy remainder of node - */ - Node_Copy(from, newnode, key); - newnode->sortop = from->sortop; + COPY_NODE_FIELD(key); + COPY_SCALAR_FIELD(sortop); return newnode; } -/* ---------------- - * _copyRestrictInfo - * ---------------- +/* + * _copyRestrictInfo */ static RestrictInfo * _copyRestrictInfo(RestrictInfo *from) { RestrictInfo *newnode = makeNode(RestrictInfo); - /* - * copy remainder of node - */ - Node_Copy(from, newnode, clause); - newnode->ispusheddown = from->ispusheddown; - Node_Copy(from, newnode, subclauseindices); - newnode->eval_cost = from->eval_cost; - newnode->this_selec = from->this_selec; - newnode->mergejoinoperator = from->mergejoinoperator; - newnode->left_sortop = from->left_sortop; - newnode->right_sortop = from->right_sortop; + COPY_NODE_FIELD(clause); + COPY_SCALAR_FIELD(ispusheddown); + COPY_NODE_FIELD(subclauseindices); /* XXX probably bad */ + COPY_SCALAR_FIELD(eval_cost); + COPY_SCALAR_FIELD(this_selec); + COPY_SCALAR_FIELD(mergejoinoperator); + COPY_SCALAR_FIELD(left_sortop); + COPY_SCALAR_FIELD(right_sortop); /* * Do not copy pathkeys, since they'd not be canonical in a copied @@ -1467,48 +1259,41 @@ _copyRestrictInfo(RestrictInfo *from) */ newnode->left_pathkey = NIL; newnode->right_pathkey = NIL; - newnode->left_mergescansel = from->left_mergescansel; - newnode->right_mergescansel = from->right_mergescansel; - newnode->hashjoinoperator = from->hashjoinoperator; - newnode->left_bucketsize = from->left_bucketsize; - newnode->right_bucketsize = from->right_bucketsize; + + COPY_SCALAR_FIELD(left_mergescansel); + COPY_SCALAR_FIELD(right_mergescansel); + COPY_SCALAR_FIELD(hashjoinoperator); + COPY_SCALAR_FIELD(left_bucketsize); + COPY_SCALAR_FIELD(right_bucketsize); return newnode; } -/* ---------------- - * _copyJoinInfo - * ---------------- +/* + * _copyJoinInfo */ static JoinInfo * _copyJoinInfo(JoinInfo *from) { JoinInfo *newnode = makeNode(JoinInfo); - /* - * copy remainder of node - */ - newnode->unjoined_relids = listCopy(from->unjoined_relids); - Node_Copy(from, newnode, jinfo_restrictinfo); + COPY_INTLIST_FIELD(unjoined_relids); + COPY_NODE_FIELD(jinfo_restrictinfo); return newnode; } -/* ---------------- - * _copyInnerIndexscanInfo - * ---------------- +/* + * _copyInnerIndexscanInfo */ static InnerIndexscanInfo * _copyInnerIndexscanInfo(InnerIndexscanInfo *from) { InnerIndexscanInfo *newnode = makeNode(InnerIndexscanInfo); - /* - * copy remainder of node - */ - newnode->other_relids = listCopy(from->other_relids); - newnode->isouterjoin = from->isouterjoin; - Node_Copy(from, newnode, best_innerpath); + COPY_INTLIST_FIELD(other_relids); + COPY_SCALAR_FIELD(isouterjoin); + COPY_NODE_FIELD(best_innerpath); return newnode; } @@ -1523,9 +1308,10 @@ _copyTargetEntry(TargetEntry *from) { TargetEntry *newnode = makeNode(TargetEntry); - Node_Copy(from, newnode, resdom); - Node_Copy(from, newnode, fjoin); - Node_Copy(from, newnode, expr); + COPY_NODE_FIELD(resdom); + COPY_NODE_FIELD(fjoin); + COPY_NODE_FIELD(expr); + return newnode; } @@ -1534,20 +1320,20 @@ _copyRangeTblEntry(RangeTblEntry *from) { RangeTblEntry *newnode = makeNode(RangeTblEntry); - newnode->rtekind = from->rtekind; - newnode->relid = from->relid; - Node_Copy(from, newnode, subquery); - Node_Copy(from, newnode, funcexpr); - Node_Copy(from, newnode, coldeflist); - newnode->jointype = from->jointype; - Node_Copy(from, newnode, joinaliasvars); - Node_Copy(from, newnode, alias); - Node_Copy(from, newnode, eref); - newnode->inh = from->inh; - newnode->inFromCl = from->inFromCl; - newnode->checkForRead = from->checkForRead; - newnode->checkForWrite = from->checkForWrite; - newnode->checkAsUser = from->checkAsUser; + COPY_SCALAR_FIELD(rtekind); + COPY_SCALAR_FIELD(relid); + COPY_NODE_FIELD(subquery); + COPY_NODE_FIELD(funcexpr); + COPY_NODE_FIELD(coldeflist); + COPY_SCALAR_FIELD(jointype); + COPY_NODE_FIELD(joinaliasvars); + COPY_NODE_FIELD(alias); + COPY_NODE_FIELD(eref); + COPY_SCALAR_FIELD(inh); + COPY_SCALAR_FIELD(inFromCl); + COPY_SCALAR_FIELD(checkForRead); + COPY_SCALAR_FIELD(checkForWrite); + COPY_SCALAR_FIELD(checkAsUser); return newnode; } @@ -1557,17 +1343,16 @@ _copyFkConstraint(FkConstraint *from) { FkConstraint *newnode = makeNode(FkConstraint); - if (from->constr_name) - newnode->constr_name = pstrdup(from->constr_name); - Node_Copy(from, newnode, pktable); - Node_Copy(from, newnode, fk_attrs); - Node_Copy(from, newnode, pk_attrs); - newnode->fk_matchtype = from->fk_matchtype; - newnode->fk_upd_action = from->fk_upd_action; - newnode->fk_del_action = from->fk_del_action; - newnode->deferrable = from->deferrable; - newnode->initdeferred = from->initdeferred; - newnode->skip_validation = from->skip_validation; + COPY_STRING_FIELD(constr_name); + 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_SCALAR_FIELD(deferrable); + COPY_SCALAR_FIELD(initdeferred); + COPY_SCALAR_FIELD(skip_validation); return newnode; } @@ -1577,8 +1362,19 @@ _copySortClause(SortClause *from) { SortClause *newnode = makeNode(SortClause); - newnode->tleSortGroupRef = from->tleSortGroupRef; - newnode->sortop = from->sortop; + COPY_SCALAR_FIELD(tleSortGroupRef); + COPY_SCALAR_FIELD(sortop); + + return newnode; +} + +static GroupClause * +_copyGroupClause(GroupClause *from) +{ + GroupClause *newnode = makeNode(GroupClause); + + COPY_SCALAR_FIELD(tleSortGroupRef); + COPY_SCALAR_FIELD(sortop); return newnode; } @@ -1588,10 +1384,10 @@ _copyAExpr(A_Expr *from) { A_Expr *newnode = makeNode(A_Expr); - newnode->oper = from->oper; - Node_Copy(from, newnode, name); - Node_Copy(from, newnode, lexpr); - Node_Copy(from, newnode, rexpr); + COPY_SCALAR_FIELD(oper); + COPY_NODE_FIELD(name); + COPY_NODE_FIELD(lexpr); + COPY_NODE_FIELD(rexpr); return newnode; } @@ -1601,8 +1397,8 @@ _copyColumnRef(ColumnRef *from) { ColumnRef *newnode = makeNode(ColumnRef); - Node_Copy(from, newnode, fields); - Node_Copy(from, newnode, indirection); + COPY_NODE_FIELD(fields); + COPY_NODE_FIELD(indirection); return newnode; } @@ -1612,9 +1408,9 @@ _copyParamRef(ParamRef *from) { ParamRef *newnode = makeNode(ParamRef); - newnode->number = from->number; - Node_Copy(from, newnode, fields); - Node_Copy(from, newnode, indirection); + COPY_SCALAR_FIELD(number); + COPY_NODE_FIELD(fields); + COPY_NODE_FIELD(indirection); return newnode; } @@ -1625,16 +1421,16 @@ _copyAConst(A_Const *from) A_Const *newnode = makeNode(A_Const); /* This part must duplicate _copyValue */ - newnode->val.type = from->val.type; + COPY_SCALAR_FIELD(val.type); switch (from->val.type) { case T_Integer: - newnode->val.val.ival = from->val.val.ival; + COPY_SCALAR_FIELD(val.val.ival); break; case T_Float: case T_String: case T_BitString: - newnode->val.val.str = pstrdup(from->val.val.str); + COPY_STRING_FIELD(val.val.str); break; case T_Null: /* nothing to do */ @@ -1644,7 +1440,7 @@ _copyAConst(A_Const *from) break; } - Node_Copy(from, newnode, typename); + COPY_NODE_FIELD(typename); return newnode; } @@ -1654,10 +1450,10 @@ _copyFuncCall(FuncCall *from) { FuncCall *newnode = makeNode(FuncCall); - Node_Copy(from, newnode, funcname); - Node_Copy(from, newnode, args); - newnode->agg_star = from->agg_star; - newnode->agg_distinct = from->agg_distinct; + COPY_NODE_FIELD(funcname); + COPY_NODE_FIELD(args); + COPY_SCALAR_FIELD(agg_star); + COPY_SCALAR_FIELD(agg_distinct); return newnode; } @@ -1667,8 +1463,8 @@ _copyAIndices(A_Indices *from) { A_Indices *newnode = makeNode(A_Indices); - Node_Copy(from, newnode, lidx); - Node_Copy(from, newnode, uidx); + COPY_NODE_FIELD(lidx); + COPY_NODE_FIELD(uidx); return newnode; } @@ -1678,9 +1474,9 @@ _copyExprFieldSelect(ExprFieldSelect *from) { ExprFieldSelect *newnode = makeNode(ExprFieldSelect); - Node_Copy(from, newnode, arg); - Node_Copy(from, newnode, fields); - Node_Copy(from, newnode, indirection); + COPY_NODE_FIELD(arg); + COPY_NODE_FIELD(fields); + COPY_NODE_FIELD(indirection); return newnode; } @@ -1690,10 +1486,9 @@ _copyResTarget(ResTarget *from) { ResTarget *newnode = makeNode(ResTarget); - if (from->name) - newnode->name = pstrdup(from->name); - Node_Copy(from, newnode, indirection); - Node_Copy(from, newnode, val); + COPY_STRING_FIELD(name); + COPY_NODE_FIELD(indirection); + COPY_NODE_FIELD(val); return newnode; } @@ -1703,13 +1498,13 @@ _copyTypeName(TypeName *from) { TypeName *newnode = makeNode(TypeName); - Node_Copy(from, newnode, names); - newnode->typeid = from->typeid; - newnode->timezone = from->timezone; - newnode->setof = from->setof; - newnode->pct_type = from->pct_type; - newnode->typmod = from->typmod; - Node_Copy(from, newnode, arrayBounds); + COPY_NODE_FIELD(names); + COPY_SCALAR_FIELD(typeid); + COPY_SCALAR_FIELD(timezone); + COPY_SCALAR_FIELD(setof); + COPY_SCALAR_FIELD(pct_type); + COPY_SCALAR_FIELD(typmod); + COPY_NODE_FIELD(arrayBounds); return newnode; } @@ -1719,38 +1514,8 @@ _copySortGroupBy(SortGroupBy *from) { SortGroupBy *newnode = makeNode(SortGroupBy); - Node_Copy(from, newnode, useOp); - Node_Copy(from, newnode, node); - - return newnode; -} - -static Alias * -_copyAlias(Alias *from) -{ - Alias *newnode = makeNode(Alias); - - if (from->aliasname) - newnode->aliasname = pstrdup(from->aliasname); - Node_Copy(from, newnode, colnames); - - return newnode; -} - -static RangeVar * -_copyRangeVar(RangeVar *from) -{ - RangeVar *newnode = makeNode(RangeVar); - - if (from->catalogname) - newnode->catalogname = pstrdup(from->catalogname); - if (from->schemaname) - newnode->schemaname = pstrdup(from->schemaname); - if (from->relname) - newnode->relname = pstrdup(from->relname); - newnode->inhOpt = from->inhOpt; - newnode->istemp = from->istemp; - Node_Copy(from, newnode, alias); + COPY_NODE_FIELD(useOp); + COPY_NODE_FIELD(node); return newnode; } @@ -1760,8 +1525,8 @@ _copyRangeSubselect(RangeSubselect *from) { RangeSubselect *newnode = makeNode(RangeSubselect); - Node_Copy(from, newnode, subquery); - Node_Copy(from, newnode, alias); + COPY_NODE_FIELD(subquery); + COPY_NODE_FIELD(alias); return newnode; } @@ -1771,9 +1536,9 @@ _copyRangeFunction(RangeFunction *from) { RangeFunction *newnode = makeNode(RangeFunction); - Node_Copy(from, newnode, funccallnode); - Node_Copy(from, newnode, alias); - Node_Copy(from, newnode, coldeflist); + COPY_NODE_FIELD(funccallnode); + COPY_NODE_FIELD(alias); + COPY_NODE_FIELD(coldeflist); return newnode; } @@ -1783,8 +1548,8 @@ _copyTypeCast(TypeCast *from) { TypeCast *newnode = makeNode(TypeCast); - Node_Copy(from, newnode, arg); - Node_Copy(from, newnode, typename); + COPY_NODE_FIELD(arg); + COPY_NODE_FIELD(typename); return newnode; } @@ -1794,11 +1559,10 @@ _copyIndexElem(IndexElem *from) { IndexElem *newnode = makeNode(IndexElem); - if (from->name) - newnode->name = pstrdup(from->name); - Node_Copy(from, newnode, funcname); - Node_Copy(from, newnode, args); - Node_Copy(from, newnode, opclass); + COPY_STRING_FIELD(name); + COPY_NODE_FIELD(funcname); + COPY_NODE_FIELD(args); + COPY_NODE_FIELD(opclass); return newnode; } @@ -1808,17 +1572,15 @@ _copyColumnDef(ColumnDef *from) { ColumnDef *newnode = makeNode(ColumnDef); - if (from->colname) - newnode->colname = pstrdup(from->colname); - Node_Copy(from, newnode, typename); - newnode->inhcount = from->inhcount; - newnode->is_local = from->is_local; - newnode->is_not_null = from->is_not_null; - Node_Copy(from, newnode, raw_default); - if (from->cooked_default) - newnode->cooked_default = pstrdup(from->cooked_default); - Node_Copy(from, newnode, constraints); - Node_Copy(from, newnode, support); + COPY_STRING_FIELD(colname); + COPY_NODE_FIELD(typename); + COPY_SCALAR_FIELD(inhcount); + COPY_SCALAR_FIELD(is_local); + COPY_SCALAR_FIELD(is_not_null); + COPY_NODE_FIELD(raw_default); + COPY_STRING_FIELD(cooked_default); + COPY_NODE_FIELD(constraints); + COPY_NODE_FIELD(support); return newnode; } @@ -1828,62 +1590,131 @@ _copyConstraint(Constraint *from) { Constraint *newnode = makeNode(Constraint); - newnode->contype = from->contype; - if (from->name) - newnode->name = pstrdup(from->name); - Node_Copy(from, newnode, raw_expr); - if (from->cooked_expr) - newnode->cooked_expr = pstrdup(from->cooked_expr); - Node_Copy(from, newnode, keys); + COPY_SCALAR_FIELD(contype); + COPY_STRING_FIELD(name); + COPY_NODE_FIELD(raw_expr); + COPY_STRING_FIELD(cooked_expr); + COPY_NODE_FIELD(keys); return newnode; } -static DefElem * -_copyDefElem(DefElem *from) +static CaseExpr * +_copyCaseExpr(CaseExpr *from) { - DefElem *newnode = makeNode(DefElem); + CaseExpr *newnode = makeNode(CaseExpr); - if (from->defname) - newnode->defname = pstrdup(from->defname); - Node_Copy(from, newnode, arg); + COPY_SCALAR_FIELD(casetype); + COPY_NODE_FIELD(arg); + COPY_NODE_FIELD(args); + COPY_NODE_FIELD(defresult); return newnode; } -static Query * -_copyQuery(Query *from) +static CaseWhen * +_copyCaseWhen(CaseWhen *from) { - Query *newnode = makeNode(Query); + CaseWhen *newnode = makeNode(CaseWhen); - newnode->commandType = from->commandType; - newnode->querySource = from->querySource; - Node_Copy(from, newnode, utilityStmt); - newnode->resultRelation = from->resultRelation; - Node_Copy(from, newnode, into); - newnode->isPortal = from->isPortal; - newnode->isBinary = from->isBinary; - newnode->hasAggs = from->hasAggs; - newnode->hasSubLinks = from->hasSubLinks; + COPY_NODE_FIELD(expr); + COPY_NODE_FIELD(result); - Node_Copy(from, newnode, rtable); - Node_Copy(from, newnode, jointree); + return newnode; +} - newnode->rowMarks = listCopy(from->rowMarks); +static NullTest * +_copyNullTest(NullTest *from) +{ + NullTest *newnode = makeNode(NullTest); - Node_Copy(from, newnode, targetList); + COPY_NODE_FIELD(arg); + COPY_SCALAR_FIELD(nulltesttype); - Node_Copy(from, newnode, groupClause); - Node_Copy(from, newnode, havingQual); - Node_Copy(from, newnode, distinctClause); - Node_Copy(from, newnode, sortClause); + return newnode; +} - Node_Copy(from, newnode, limitOffset); - Node_Copy(from, newnode, limitCount); +static BooleanTest * +_copyBooleanTest(BooleanTest *from) +{ + BooleanTest *newnode = makeNode(BooleanTest); - Node_Copy(from, newnode, setOperations); + COPY_NODE_FIELD(arg); + COPY_SCALAR_FIELD(booltesttype); + + return newnode; +} + +static ConstraintTest * +_copyConstraintTest(ConstraintTest *from) +{ + ConstraintTest *newnode = makeNode(ConstraintTest); + + COPY_NODE_FIELD(arg); + COPY_SCALAR_FIELD(testtype); + COPY_STRING_FIELD(name); + COPY_STRING_FIELD(domname); + COPY_NODE_FIELD(check_expr); + + return newnode; +} + +static DomainConstraintValue * +_copyDomainConstraintValue(DomainConstraintValue *from) +{ + DomainConstraintValue *newnode = makeNode(DomainConstraintValue); + + return newnode; +} + +static ConstraintTestValue * +_copyConstraintTestValue(ConstraintTestValue *from) +{ + ConstraintTestValue *newnode = makeNode(ConstraintTestValue); - newnode->resultRelations = listCopy(from->resultRelations); + COPY_SCALAR_FIELD(typeId); + COPY_SCALAR_FIELD(typeMod); + + return newnode; +} + +static DefElem * +_copyDefElem(DefElem *from) +{ + DefElem *newnode = makeNode(DefElem); + + COPY_STRING_FIELD(defname); + COPY_NODE_FIELD(arg); + + return newnode; +} + +static Query * +_copyQuery(Query *from) +{ + Query *newnode = makeNode(Query); + + COPY_SCALAR_FIELD(commandType); + COPY_SCALAR_FIELD(querySource); + COPY_NODE_FIELD(utilityStmt); + COPY_SCALAR_FIELD(resultRelation); + COPY_NODE_FIELD(into); + COPY_SCALAR_FIELD(isPortal); + COPY_SCALAR_FIELD(isBinary); + COPY_SCALAR_FIELD(hasAggs); + COPY_SCALAR_FIELD(hasSubLinks); + COPY_NODE_FIELD(rtable); + COPY_NODE_FIELD(jointree); + COPY_INTLIST_FIELD(rowMarks); + COPY_NODE_FIELD(targetList); + COPY_NODE_FIELD(groupClause); + COPY_NODE_FIELD(havingQual); + COPY_NODE_FIELD(distinctClause); + COPY_NODE_FIELD(sortClause); + COPY_NODE_FIELD(limitOffset); + COPY_NODE_FIELD(limitCount); + COPY_NODE_FIELD(setOperations); + COPY_INTLIST_FIELD(resultRelations); /* * We do not copy the planner internal fields: base_rel_list, @@ -1899,10 +1730,10 @@ _copyInsertStmt(InsertStmt *from) { InsertStmt *newnode = makeNode(InsertStmt); - Node_Copy(from, newnode, relation); - Node_Copy(from, newnode, cols); - Node_Copy(from, newnode, targetList); - Node_Copy(from, newnode, selectStmt); + COPY_NODE_FIELD(relation); + COPY_NODE_FIELD(cols); + COPY_NODE_FIELD(targetList); + COPY_NODE_FIELD(selectStmt); return newnode; } @@ -1912,8 +1743,8 @@ _copyDeleteStmt(DeleteStmt *from) { DeleteStmt *newnode = makeNode(DeleteStmt); - Node_Copy(from, newnode, relation); - Node_Copy(from, newnode, whereClause); + COPY_NODE_FIELD(relation); + COPY_NODE_FIELD(whereClause); return newnode; } @@ -1923,10 +1754,10 @@ _copyUpdateStmt(UpdateStmt *from) { UpdateStmt *newnode = makeNode(UpdateStmt); - Node_Copy(from, newnode, relation); - Node_Copy(from, newnode, targetList); - Node_Copy(from, newnode, whereClause); - Node_Copy(from, newnode, fromClause); + COPY_NODE_FIELD(relation); + COPY_NODE_FIELD(targetList); + COPY_NODE_FIELD(whereClause); + COPY_NODE_FIELD(fromClause); return newnode; } @@ -1936,25 +1767,24 @@ _copySelectStmt(SelectStmt *from) { SelectStmt *newnode = makeNode(SelectStmt); - Node_Copy(from, newnode, distinctClause); - Node_Copy(from, newnode, into); - Node_Copy(from, newnode, intoColNames); - Node_Copy(from, newnode, targetList); - Node_Copy(from, newnode, fromClause); - Node_Copy(from, newnode, whereClause); - Node_Copy(from, newnode, groupClause); - Node_Copy(from, newnode, havingClause); - Node_Copy(from, newnode, sortClause); - if (from->portalname) - newnode->portalname = pstrdup(from->portalname); - newnode->binary = from->binary; - Node_Copy(from, newnode, limitOffset); - Node_Copy(from, newnode, limitCount); - Node_Copy(from, newnode, forUpdate); - newnode->op = from->op; - newnode->all = from->all; - Node_Copy(from, newnode, larg); - Node_Copy(from, newnode, rarg); + COPY_NODE_FIELD(distinctClause); + COPY_NODE_FIELD(into); + COPY_NODE_FIELD(intoColNames); + COPY_NODE_FIELD(targetList); + COPY_NODE_FIELD(fromClause); + COPY_NODE_FIELD(whereClause); + COPY_NODE_FIELD(groupClause); + COPY_NODE_FIELD(havingClause); + COPY_NODE_FIELD(sortClause); + COPY_STRING_FIELD(portalname); + COPY_SCALAR_FIELD(binary); + COPY_NODE_FIELD(limitOffset); + COPY_NODE_FIELD(limitCount); + COPY_NODE_FIELD(forUpdate); + COPY_SCALAR_FIELD(op); + COPY_SCALAR_FIELD(all); + COPY_NODE_FIELD(larg); + COPY_NODE_FIELD(rarg); return newnode; } @@ -1964,11 +1794,11 @@ _copySetOperationStmt(SetOperationStmt *from) { SetOperationStmt *newnode = makeNode(SetOperationStmt); - newnode->op = from->op; - newnode->all = from->all; - Node_Copy(from, newnode, larg); - Node_Copy(from, newnode, rarg); - newnode->colTypes = listCopy(from->colTypes); + COPY_SCALAR_FIELD(op); + COPY_SCALAR_FIELD(all); + COPY_NODE_FIELD(larg); + COPY_NODE_FIELD(rarg); + COPY_INTLIST_FIELD(colTypes); return newnode; } @@ -1978,12 +1808,11 @@ _copyAlterTableStmt(AlterTableStmt *from) { AlterTableStmt *newnode = makeNode(AlterTableStmt); - newnode->subtype = from->subtype; - Node_Copy(from, newnode, relation); - if (from->name) - newnode->name = pstrdup(from->name); - Node_Copy(from, newnode, def); - newnode->behavior = from->behavior; + COPY_SCALAR_FIELD(subtype); + COPY_NODE_FIELD(relation); + COPY_STRING_FIELD(name); + COPY_NODE_FIELD(def); + COPY_SCALAR_FIELD(behavior); return newnode; } @@ -1993,11 +1822,11 @@ _copyGrantStmt(GrantStmt *from) { GrantStmt *newnode = makeNode(GrantStmt); - newnode->is_grant = from->is_grant; - newnode->objtype = from->objtype; - Node_Copy(from, newnode, objects); - newnode->privileges = listCopy(from->privileges); - Node_Copy(from, newnode, grantees); + COPY_SCALAR_FIELD(is_grant); + COPY_SCALAR_FIELD(objtype); + COPY_NODE_FIELD(objects); + COPY_INTLIST_FIELD(privileges); + COPY_NODE_FIELD(grantees); return newnode; } @@ -2007,10 +1836,8 @@ _copyPrivGrantee(PrivGrantee *from) { PrivGrantee *newnode = makeNode(PrivGrantee); - if (from->username) - newnode->username = pstrdup(from->username); - if (from->groupname) - newnode->groupname = pstrdup(from->groupname); + COPY_STRING_FIELD(username); + COPY_STRING_FIELD(groupname); return newnode; } @@ -2020,8 +1847,8 @@ _copyFuncWithArgs(FuncWithArgs *from) { FuncWithArgs *newnode = makeNode(FuncWithArgs); - Node_Copy(from, newnode, funcname); - Node_Copy(from, newnode, funcargs); + COPY_NODE_FIELD(funcname); + COPY_NODE_FIELD(funcargs); return newnode; } @@ -2040,8 +1867,7 @@ _copyClosePortalStmt(ClosePortalStmt *from) { ClosePortalStmt *newnode = makeNode(ClosePortalStmt); - if (from->portalname) - newnode->portalname = pstrdup(from->portalname); + COPY_STRING_FIELD(portalname); return newnode; } @@ -2051,9 +1877,8 @@ _copyClusterStmt(ClusterStmt *from) { ClusterStmt *newnode = makeNode(ClusterStmt); - Node_Copy(from, newnode, relation); - if (from->indexname) - newnode->indexname = pstrdup(from->indexname); + COPY_NODE_FIELD(relation); + COPY_STRING_FIELD(indexname); return newnode; } @@ -2063,12 +1888,11 @@ _copyCopyStmt(CopyStmt *from) { CopyStmt *newnode = makeNode(CopyStmt); - Node_Copy(from, newnode, relation); - Node_Copy(from, newnode, attlist); - newnode->is_from = from->is_from; - if (from->filename) - newnode->filename = pstrdup(from->filename); - Node_Copy(from, newnode, options); + COPY_NODE_FIELD(relation); + COPY_NODE_FIELD(attlist); + COPY_SCALAR_FIELD(is_from); + COPY_STRING_FIELD(filename); + COPY_NODE_FIELD(options); return newnode; } @@ -2078,12 +1902,12 @@ _copyCreateStmt(CreateStmt *from) { CreateStmt *newnode = makeNode(CreateStmt); - Node_Copy(from, newnode, relation); - Node_Copy(from, newnode, tableElts); - Node_Copy(from, newnode, inhRelations); - Node_Copy(from, newnode, constraints); - newnode->hasoids = from->hasoids; - newnode->oncommit = from->oncommit; + COPY_NODE_FIELD(relation); + COPY_NODE_FIELD(tableElts); + COPY_NODE_FIELD(inhRelations); + COPY_NODE_FIELD(constraints); + COPY_SCALAR_FIELD(hasoids); + COPY_SCALAR_FIELD(oncommit); return newnode; } @@ -2093,9 +1917,9 @@ _copyDefineStmt(DefineStmt *from) { DefineStmt *newnode = makeNode(DefineStmt); - newnode->defType = from->defType; - Node_Copy(from, newnode, defnames); - Node_Copy(from, newnode, definition); + COPY_SCALAR_FIELD(defType); + COPY_NODE_FIELD(defnames); + COPY_NODE_FIELD(definition); return newnode; } @@ -2105,9 +1929,9 @@ _copyDropStmt(DropStmt *from) { DropStmt *newnode = makeNode(DropStmt); - Node_Copy(from, newnode, objects); - newnode->removeType = from->removeType; - newnode->behavior = from->behavior; + COPY_NODE_FIELD(objects); + COPY_SCALAR_FIELD(removeType); + COPY_SCALAR_FIELD(behavior); return newnode; } @@ -2117,7 +1941,7 @@ _copyTruncateStmt(TruncateStmt *from) { TruncateStmt *newnode = makeNode(TruncateStmt); - Node_Copy(from, newnode, relation); + COPY_NODE_FIELD(relation); return newnode; } @@ -2127,11 +1951,10 @@ _copyCommentStmt(CommentStmt *from) { CommentStmt *newnode = makeNode(CommentStmt); - newnode->objtype = from->objtype; - Node_Copy(from, newnode, objname); - Node_Copy(from, newnode, objargs); - if (from->comment) - newnode->comment = pstrdup(from->comment); + COPY_SCALAR_FIELD(objtype); + COPY_NODE_FIELD(objname); + COPY_NODE_FIELD(objargs); + COPY_STRING_FIELD(comment); return newnode; } @@ -2141,10 +1964,10 @@ _copyFetchStmt(FetchStmt *from) { FetchStmt *newnode = makeNode(FetchStmt); - newnode->direction = from->direction; - newnode->howMany = from->howMany; - newnode->portalname = pstrdup(from->portalname); - newnode->ismove = from->ismove; + COPY_SCALAR_FIELD(direction); + COPY_SCALAR_FIELD(howMany); + COPY_STRING_FIELD(portalname); + COPY_SCALAR_FIELD(ismove); return newnode; } @@ -2154,15 +1977,15 @@ _copyIndexStmt(IndexStmt *from) { IndexStmt *newnode = makeNode(IndexStmt); - newnode->idxname = pstrdup(from->idxname); - Node_Copy(from, newnode, relation); - newnode->accessMethod = pstrdup(from->accessMethod); - Node_Copy(from, newnode, indexParams); - Node_Copy(from, newnode, whereClause); - Node_Copy(from, newnode, rangetable); - newnode->unique = from->unique; - newnode->primary = from->primary; - newnode->isconstraint = from->isconstraint; + COPY_STRING_FIELD(idxname); + COPY_NODE_FIELD(relation); + COPY_STRING_FIELD(accessMethod); + COPY_NODE_FIELD(indexParams); + COPY_NODE_FIELD(whereClause); + COPY_NODE_FIELD(rangetable); + COPY_SCALAR_FIELD(unique); + COPY_SCALAR_FIELD(primary); + COPY_SCALAR_FIELD(isconstraint); return newnode; } @@ -2172,12 +1995,12 @@ _copyCreateFunctionStmt(CreateFunctionStmt *from) { CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt); - newnode->replace = from->replace; - Node_Copy(from, newnode, funcname); - Node_Copy(from, newnode, argTypes); - Node_Copy(from, newnode, returnType); - Node_Copy(from, newnode, options); - Node_Copy(from, newnode, withClause); + COPY_SCALAR_FIELD(replace); + COPY_NODE_FIELD(funcname); + COPY_NODE_FIELD(argTypes); + COPY_NODE_FIELD(returnType); + COPY_NODE_FIELD(options); + COPY_NODE_FIELD(withClause); return newnode; } @@ -2187,9 +2010,9 @@ _copyRemoveAggrStmt(RemoveAggrStmt *from) { RemoveAggrStmt *newnode = makeNode(RemoveAggrStmt); - Node_Copy(from, newnode, aggname); - Node_Copy(from, newnode, aggtype); - newnode->behavior = from->behavior; + COPY_NODE_FIELD(aggname); + COPY_NODE_FIELD(aggtype); + COPY_SCALAR_FIELD(behavior); return newnode; } @@ -2199,9 +2022,9 @@ _copyRemoveFuncStmt(RemoveFuncStmt *from) { RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt); - Node_Copy(from, newnode, funcname); - Node_Copy(from, newnode, args); - newnode->behavior = from->behavior; + COPY_NODE_FIELD(funcname); + COPY_NODE_FIELD(args); + COPY_SCALAR_FIELD(behavior); return newnode; } @@ -2211,9 +2034,9 @@ _copyRemoveOperStmt(RemoveOperStmt *from) { RemoveOperStmt *newnode = makeNode(RemoveOperStmt); - Node_Copy(from, newnode, opname); - Node_Copy(from, newnode, args); - newnode->behavior = from->behavior; + COPY_NODE_FIELD(opname); + COPY_NODE_FIELD(args); + COPY_SCALAR_FIELD(behavior); return newnode; } @@ -2223,10 +2046,9 @@ _copyRemoveOpClassStmt(RemoveOpClassStmt *from) { RemoveOpClassStmt *newnode = makeNode(RemoveOpClassStmt); - Node_Copy(from, newnode, opclassname); - if (from->amname) - newnode->amname = pstrdup(from->amname); - newnode->behavior = from->behavior; + COPY_NODE_FIELD(opclassname); + COPY_STRING_FIELD(amname); + COPY_SCALAR_FIELD(behavior); return newnode; } @@ -2236,12 +2058,10 @@ _copyRenameStmt(RenameStmt *from) { RenameStmt *newnode = makeNode(RenameStmt); - Node_Copy(from, newnode, relation); - if (from->oldname) - newnode->oldname = pstrdup(from->oldname); - if (from->newname) - newnode->newname = pstrdup(from->newname); - newnode->renameType = from->renameType; + COPY_NODE_FIELD(relation); + COPY_STRING_FIELD(oldname); + COPY_STRING_FIELD(newname); + COPY_SCALAR_FIELD(renameType); return newnode; } @@ -2251,13 +2071,13 @@ _copyRuleStmt(RuleStmt *from) { RuleStmt *newnode = makeNode(RuleStmt); - Node_Copy(from, newnode, relation); - newnode->rulename = pstrdup(from->rulename); - Node_Copy(from, newnode, whereClause); - newnode->event = from->event; - newnode->instead = from->instead; - newnode->replace = from->replace; - Node_Copy(from, newnode, actions); + 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; } @@ -2267,7 +2087,7 @@ _copyNotifyStmt(NotifyStmt *from) { NotifyStmt *newnode = makeNode(NotifyStmt); - Node_Copy(from, newnode, relation); + COPY_NODE_FIELD(relation); return newnode; } @@ -2277,7 +2097,7 @@ _copyListenStmt(ListenStmt *from) { ListenStmt *newnode = makeNode(ListenStmt); - Node_Copy(from, newnode, relation); + COPY_NODE_FIELD(relation); return newnode; } @@ -2287,7 +2107,7 @@ _copyUnlistenStmt(UnlistenStmt *from) { UnlistenStmt *newnode = makeNode(UnlistenStmt); - Node_Copy(from, newnode, relation); + COPY_NODE_FIELD(relation); return newnode; } @@ -2297,8 +2117,8 @@ _copyTransactionStmt(TransactionStmt *from) { TransactionStmt *newnode = makeNode(TransactionStmt); - newnode->command = from->command; - Node_Copy(from, newnode, options); + COPY_SCALAR_FIELD(command); + COPY_NODE_FIELD(options); return newnode; } @@ -2308,8 +2128,8 @@ _copyCompositeTypeStmt(CompositeTypeStmt *from) { CompositeTypeStmt *newnode = makeNode(CompositeTypeStmt); - Node_Copy(from, newnode, typevar); - Node_Copy(from, newnode, coldeflist); + COPY_NODE_FIELD(typevar); + COPY_NODE_FIELD(coldeflist); return newnode; } @@ -2319,10 +2139,10 @@ _copyViewStmt(ViewStmt *from) { ViewStmt *newnode = makeNode(ViewStmt); - Node_Copy(from, newnode, view); - Node_Copy(from, newnode, aliases); - Node_Copy(from, newnode, query); - newnode->replace = from->replace; + COPY_NODE_FIELD(view); + COPY_NODE_FIELD(aliases); + COPY_NODE_FIELD(query); + COPY_SCALAR_FIELD(replace); return newnode; } @@ -2332,8 +2152,7 @@ _copyLoadStmt(LoadStmt *from) { LoadStmt *newnode = makeNode(LoadStmt); - if (from->filename) - newnode->filename = pstrdup(from->filename); + COPY_STRING_FIELD(filename); return newnode; } @@ -2343,9 +2162,9 @@ _copyCreateDomainStmt(CreateDomainStmt *from) { CreateDomainStmt *newnode = makeNode(CreateDomainStmt); - Node_Copy(from, newnode, domainname); - Node_Copy(from, newnode, typename); - Node_Copy(from, newnode, constraints); + COPY_NODE_FIELD(domainname); + COPY_NODE_FIELD(typename); + COPY_NODE_FIELD(constraints); return newnode; } @@ -2355,12 +2174,11 @@ _copyCreateOpClassStmt(CreateOpClassStmt *from) { CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt); - Node_Copy(from, newnode, opclassname); - if (from->amname) - newnode->amname = pstrdup(from->amname); - Node_Copy(from, newnode, datatype); - Node_Copy(from, newnode, items); - newnode->isDefault = from->isDefault; + COPY_NODE_FIELD(opclassname); + COPY_STRING_FIELD(amname); + COPY_NODE_FIELD(datatype); + COPY_NODE_FIELD(items); + COPY_SCALAR_FIELD(isDefault); return newnode; } @@ -2370,12 +2188,12 @@ _copyCreateOpClassItem(CreateOpClassItem *from) { CreateOpClassItem *newnode = makeNode(CreateOpClassItem); - newnode->itemtype = from->itemtype; - Node_Copy(from, newnode, name); - Node_Copy(from, newnode, args); - newnode->number = from->number; - newnode->recheck = from->recheck; - Node_Copy(from, newnode, storedtype); + COPY_SCALAR_FIELD(itemtype); + COPY_NODE_FIELD(name); + COPY_NODE_FIELD(args); + COPY_SCALAR_FIELD(number); + COPY_SCALAR_FIELD(recheck); + COPY_NODE_FIELD(storedtype); return newnode; } @@ -2385,9 +2203,8 @@ _copyCreatedbStmt(CreatedbStmt *from) { CreatedbStmt *newnode = makeNode(CreatedbStmt); - if (from->dbname) - newnode->dbname = pstrdup(from->dbname); - Node_Copy(from, newnode, options); + COPY_STRING_FIELD(dbname); + COPY_NODE_FIELD(options); return newnode; } @@ -2397,11 +2214,9 @@ _copyAlterDatabaseSetStmt(AlterDatabaseSetStmt *from) { AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt); - if (from->dbname) - newnode->dbname = pstrdup(from->dbname); - if (from->variable) - newnode->variable = pstrdup(from->variable); - Node_Copy(from, newnode, value); + COPY_STRING_FIELD(dbname); + COPY_STRING_FIELD(variable); + COPY_NODE_FIELD(value); return newnode; } @@ -2411,8 +2226,7 @@ _copyDropdbStmt(DropdbStmt *from) { DropdbStmt *newnode = makeNode(DropdbStmt); - if (from->dbname) - newnode->dbname = pstrdup(from->dbname); + COPY_STRING_FIELD(dbname); return newnode; } @@ -2422,13 +2236,13 @@ _copyVacuumStmt(VacuumStmt *from) { VacuumStmt *newnode = makeNode(VacuumStmt); - newnode->vacuum = from->vacuum; - newnode->full = from->full; - newnode->analyze = from->analyze; - newnode->freeze = from->freeze; - newnode->verbose = from->verbose; - Node_Copy(from, newnode, relation); - Node_Copy(from, newnode, va_cols); + COPY_SCALAR_FIELD(vacuum); + COPY_SCALAR_FIELD(full); + COPY_SCALAR_FIELD(analyze); + COPY_SCALAR_FIELD(freeze); + COPY_SCALAR_FIELD(verbose); + COPY_NODE_FIELD(relation); + COPY_NODE_FIELD(va_cols); return newnode; } @@ -2438,9 +2252,9 @@ _copyExplainStmt(ExplainStmt *from) { ExplainStmt *newnode = makeNode(ExplainStmt); - Node_Copy(from, newnode, query); - newnode->verbose = from->verbose; - newnode->analyze = from->analyze; + COPY_NODE_FIELD(query); + COPY_SCALAR_FIELD(verbose); + COPY_SCALAR_FIELD(analyze); return newnode; } @@ -2450,8 +2264,8 @@ _copyCreateSeqStmt(CreateSeqStmt *from) { CreateSeqStmt *newnode = makeNode(CreateSeqStmt); - Node_Copy(from, newnode, sequence); - Node_Copy(from, newnode, options); + COPY_NODE_FIELD(sequence); + COPY_NODE_FIELD(options); return newnode; } @@ -2461,10 +2275,9 @@ _copyVariableSetStmt(VariableSetStmt *from) { VariableSetStmt *newnode = makeNode(VariableSetStmt); - if (from->name) - newnode->name = pstrdup(from->name); - Node_Copy(from, newnode, args); - newnode->is_local = from->is_local; + COPY_STRING_FIELD(name); + COPY_NODE_FIELD(args); + COPY_SCALAR_FIELD(is_local); return newnode; } @@ -2474,8 +2287,7 @@ _copyVariableShowStmt(VariableShowStmt *from) { VariableShowStmt *newnode = makeNode(VariableShowStmt); - if (from->name) - newnode->name = pstrdup(from->name); + COPY_STRING_FIELD(name); return newnode; } @@ -2485,8 +2297,7 @@ _copyVariableResetStmt(VariableResetStmt *from) { VariableResetStmt *newnode = makeNode(VariableResetStmt); - if (from->name) - newnode->name = pstrdup(from->name); + COPY_STRING_FIELD(name); return newnode; } @@ -2496,18 +2307,17 @@ _copyCreateTrigStmt(CreateTrigStmt *from) { CreateTrigStmt *newnode = makeNode(CreateTrigStmt); - if (from->trigname) - newnode->trigname = pstrdup(from->trigname); - Node_Copy(from, newnode, relation); - Node_Copy(from, newnode, funcname); - Node_Copy(from, newnode, args); - newnode->before = from->before; - newnode->row = from->row; - memcpy(newnode->actions, from->actions, sizeof(from->actions)); - newnode->isconstraint = from->isconstraint; - newnode->deferrable = from->deferrable; - newnode->initdeferred = from->initdeferred; - Node_Copy(from, newnode, constrrel); + COPY_STRING_FIELD(trigname); + COPY_NODE_FIELD(relation); + COPY_NODE_FIELD(funcname); + COPY_NODE_FIELD(args); + COPY_SCALAR_FIELD(before); + COPY_SCALAR_FIELD(row); + strcpy(newnode->actions, from->actions); /* in-line string field */ + COPY_SCALAR_FIELD(isconstraint); + COPY_SCALAR_FIELD(deferrable); + COPY_SCALAR_FIELD(initdeferred); + COPY_NODE_FIELD(constrrel); return newnode; } @@ -2517,11 +2327,10 @@ _copyDropPropertyStmt(DropPropertyStmt *from) { DropPropertyStmt *newnode = makeNode(DropPropertyStmt); - Node_Copy(from, newnode, relation); - if (from->property) - newnode->property = pstrdup(from->property); - newnode->removeType = from->removeType; - newnode->behavior = from->behavior; + COPY_NODE_FIELD(relation); + COPY_STRING_FIELD(property); + COPY_SCALAR_FIELD(removeType); + COPY_SCALAR_FIELD(behavior); return newnode; } @@ -2531,11 +2340,10 @@ _copyCreatePLangStmt(CreatePLangStmt *from) { CreatePLangStmt *newnode = makeNode(CreatePLangStmt); - if (from->plname) - newnode->plname = pstrdup(from->plname); - Node_Copy(from, newnode, plhandler); - Node_Copy(from, newnode, plvalidator); - newnode->pltrusted = from->pltrusted; + COPY_STRING_FIELD(plname); + COPY_NODE_FIELD(plhandler); + COPY_NODE_FIELD(plvalidator); + COPY_SCALAR_FIELD(pltrusted); return newnode; } @@ -2545,9 +2353,8 @@ _copyDropPLangStmt(DropPLangStmt *from) { DropPLangStmt *newnode = makeNode(DropPLangStmt); - if (from->plname) - newnode->plname = pstrdup(from->plname); - newnode->behavior = from->behavior; + COPY_STRING_FIELD(plname); + COPY_SCALAR_FIELD(behavior); return newnode; } @@ -2557,9 +2364,8 @@ _copyCreateUserStmt(CreateUserStmt *from) { CreateUserStmt *newnode = makeNode(CreateUserStmt); - if (from->user) - newnode->user = pstrdup(from->user); - Node_Copy(from, newnode, options); + COPY_STRING_FIELD(user); + COPY_NODE_FIELD(options); return newnode; } @@ -2569,9 +2375,8 @@ _copyAlterUserStmt(AlterUserStmt *from) { AlterUserStmt *newnode = makeNode(AlterUserStmt); - if (from->user) - newnode->user = pstrdup(from->user); - Node_Copy(from, newnode, options); + COPY_STRING_FIELD(user); + COPY_NODE_FIELD(options); return newnode; } @@ -2581,11 +2386,9 @@ _copyAlterUserSetStmt(AlterUserSetStmt *from) { AlterUserSetStmt *newnode = makeNode(AlterUserSetStmt); - if (from->user) - newnode->user = pstrdup(from->user); - if (from->variable) - newnode->variable = pstrdup(from->variable); - Node_Copy(from, newnode, value); + COPY_STRING_FIELD(user); + COPY_STRING_FIELD(variable); + COPY_NODE_FIELD(value); return newnode; } @@ -2595,7 +2398,7 @@ _copyDropUserStmt(DropUserStmt *from) { DropUserStmt *newnode = makeNode(DropUserStmt); - Node_Copy(from, newnode, users); + COPY_NODE_FIELD(users); return newnode; } @@ -2605,9 +2408,8 @@ _copyLockStmt(LockStmt *from) { LockStmt *newnode = makeNode(LockStmt); - Node_Copy(from, newnode, relations); - - newnode->mode = from->mode; + COPY_NODE_FIELD(relations); + COPY_SCALAR_FIELD(mode); return newnode; } @@ -2617,8 +2419,8 @@ _copyConstraintsSetStmt(ConstraintsSetStmt *from) { ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt); - Node_Copy(from, newnode, constraints); - newnode->deferred = from->deferred; + COPY_NODE_FIELD(constraints); + COPY_SCALAR_FIELD(deferred); return newnode; } @@ -2628,9 +2430,8 @@ _copyCreateGroupStmt(CreateGroupStmt *from) { CreateGroupStmt *newnode = makeNode(CreateGroupStmt); - if (from->name) - newnode->name = pstrdup(from->name); - Node_Copy(from, newnode, options); + COPY_STRING_FIELD(name); + COPY_NODE_FIELD(options); return newnode; } @@ -2640,10 +2441,9 @@ _copyAlterGroupStmt(AlterGroupStmt *from) { AlterGroupStmt *newnode = makeNode(AlterGroupStmt); - if (from->name) - newnode->name = pstrdup(from->name); - newnode->action = from->action; - Node_Copy(from, newnode, listUsers); + COPY_STRING_FIELD(name); + COPY_SCALAR_FIELD(action); + COPY_NODE_FIELD(listUsers); return newnode; } @@ -2653,8 +2453,7 @@ _copyDropGroupStmt(DropGroupStmt *from) { DropGroupStmt *newnode = makeNode(DropGroupStmt); - if (from->name) - newnode->name = pstrdup(from->name); + COPY_STRING_FIELD(name); return newnode; } @@ -2664,12 +2463,11 @@ _copyReindexStmt(ReindexStmt *from) { ReindexStmt *newnode = makeNode(ReindexStmt); - newnode->reindexType = from->reindexType; - Node_Copy(from, newnode, relation); - if (from->name) - newnode->name = pstrdup(from->name); - newnode->force = from->force; - newnode->all = from->all; + COPY_SCALAR_FIELD(reindexType); + COPY_NODE_FIELD(relation); + COPY_STRING_FIELD(name); + COPY_SCALAR_FIELD(force); + COPY_SCALAR_FIELD(all); return newnode; } @@ -2679,10 +2477,9 @@ _copyCreateSchemaStmt(CreateSchemaStmt *from) { CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt); - newnode->schemaname = pstrdup(from->schemaname); - if (from->authid) - newnode->authid = pstrdup(from->authid); - Node_Copy(from, newnode, schemaElts); + COPY_STRING_FIELD(schemaname); + COPY_STRING_FIELD(authid); + COPY_NODE_FIELD(schemaElts); return newnode; } @@ -2692,11 +2489,11 @@ _copyCreateConversionStmt(CreateConversionStmt *from) { CreateConversionStmt *newnode = makeNode(CreateConversionStmt); - Node_Copy(from, newnode, conversion_name); - newnode->for_encoding_name = pstrdup(from->for_encoding_name); - newnode->to_encoding_name = pstrdup(from->to_encoding_name); - Node_Copy(from, newnode, func_name); - newnode->def = from->def; + 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; } @@ -2706,10 +2503,10 @@ _copyCreateCastStmt(CreateCastStmt *from) { CreateCastStmt *newnode = makeNode(CreateCastStmt); - Node_Copy(from, newnode, sourcetype); - Node_Copy(from, newnode, targettype); - Node_Copy(from, newnode, func); - newnode->context = from->context; + COPY_NODE_FIELD(sourcetype); + COPY_NODE_FIELD(targettype); + COPY_NODE_FIELD(func); + COPY_SCALAR_FIELD(context); return newnode; } @@ -2719,9 +2516,9 @@ _copyDropCastStmt(DropCastStmt *from) { DropCastStmt *newnode = makeNode(DropCastStmt); - Node_Copy(from, newnode, sourcetype); - Node_Copy(from, newnode, targettype); - newnode->behavior = from->behavior; + COPY_NODE_FIELD(sourcetype); + COPY_NODE_FIELD(targettype); + COPY_SCALAR_FIELD(behavior); return newnode; } @@ -2731,10 +2528,10 @@ _copyPrepareStmt(PrepareStmt *from) { PrepareStmt *newnode = makeNode(PrepareStmt); - newnode->name = pstrdup(from->name); - Node_Copy(from, newnode, argtypes); - newnode->argtype_oids = listCopy(from->argtype_oids); - Node_Copy(from, newnode, query); + COPY_STRING_FIELD(name); + COPY_NODE_FIELD(argtypes); + COPY_INTLIST_FIELD(argtype_oids); + COPY_NODE_FIELD(query); return newnode; } @@ -2744,9 +2541,9 @@ _copyExecuteStmt(ExecuteStmt *from) { ExecuteStmt *newnode = makeNode(ExecuteStmt); - newnode->name = pstrdup(from->name); - Node_Copy(from, newnode, into); - Node_Copy(from, newnode, params); + COPY_STRING_FIELD(name); + COPY_NODE_FIELD(into); + COPY_NODE_FIELD(params); return newnode; } @@ -2756,7 +2553,7 @@ _copyDeallocateStmt(DeallocateStmt *from) { DeallocateStmt *newnode = makeNode(DeallocateStmt); - newnode->name = pstrdup(from->name); + COPY_STRING_FIELD(name); return newnode; } @@ -2774,16 +2571,16 @@ _copyValue(Value *from) /* See also _copyAConst when changing this code! */ - newnode->type = from->type; + COPY_SCALAR_FIELD(type); switch (from->type) { case T_Integer: - newnode->val.ival = from->val.ival; + COPY_SCALAR_FIELD(val.ival); break; case T_Float: case T_String: case T_BitString: - newnode->val.str = pstrdup(from->val.str); + COPY_STRING_FIELD(val.str); break; case T_Null: /* nothing to do */ @@ -2795,10 +2592,11 @@ _copyValue(Value *from) return newnode; } -/* ---------------- - * copyObject returns a copy of the node or list. If it is a list, it - * recursively copies its items. - * ---------------- +/* + * copyObject + * + * Create a copy of a Node tree or list. This is a "deep" copy: all + * substructure is copied too, recursively. */ void * copyObject(void *from) @@ -2889,6 +2687,12 @@ copyObject(void *from) case T_Fjoin: retval = _copyFjoin(from); break; + case T_Alias: + retval = _copyAlias(from); + break; + case T_RangeVar: + retval = _copyRangeVar(from); + break; case T_Expr: retval = _copyExpr(from); break; @@ -2904,18 +2708,15 @@ copyObject(void *from) case T_Param: retval = _copyParam(from); break; + case T_Func: + retval = _copyFunc(from); + break; case T_Aggref: retval = _copyAggref(from); break; case T_SubLink: retval = _copySubLink(from); break; - case T_Func: - retval = _copyFunc(from); - break; - case T_ArrayRef: - retval = _copyArrayRef(from); - break; case T_FieldSelect: retval = _copyFieldSelect(from); break; @@ -2925,11 +2726,14 @@ copyObject(void *from) case T_RangeTblRef: retval = _copyRangeTblRef(from); break; + case T_JoinExpr: + retval = _copyJoinExpr(from); + break; case T_FromExpr: retval = _copyFromExpr(from); break; - case T_JoinExpr: - retval = _copyJoinExpr(from); + case T_ArrayRef: + retval = _copyArrayRef(from); break; /* @@ -3239,12 +3043,6 @@ copyObject(void *from) case T_SortGroupBy: retval = _copySortGroupBy(from); break; - case T_Alias: - retval = _copyAlias(from); - break; - case T_RangeVar: - retval = _copyRangeVar(from); - break; case T_RangeSubselect: retval = _copyRangeSubselect(from); break; @@ -3318,5 +3116,6 @@ copyObject(void *from) retval = from; /* keep compiler quiet */ break; } + return retval; } |