* copyfuncs.c
* Copy functions for Postgres tree nodes.
*
- * Copyright (c) 1994, Regents of the University of California
+ * NOTE: a general convention when copying or comparing plan nodes is
+ * that we ignore the executor state subnode. We do not need to look
+ * at it because no current uses of copyObject() or equal() need to
+ * deal with already-executing plan trees. By leaving the state subnodes
+ * out, we avoid needing to write copy/compare routines for all the
+ * different executor state node types.
*
*
+ * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.94 1999/11/01 05:15:13 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.192 2002/07/01 15:27:51 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
+#include "optimizer/clauses.h"
#include "optimizer/planmain.h"
-#include "optimizer/subselect.h"
/*
if (list == NIL)
return NIL;
- newlist = nl = lcons(lfirst(list), NIL);
+ newlist = nl = makeList1(lfirst(list));
foreach(l, lnext(list))
{
- lnext(nl) = lcons(lfirst(l), NIL);
+ lnext(nl) = makeList1(lfirst(l));
nl = lnext(nl);
}
return newlist;
static void
CopyPlanFields(Plan *from, Plan *newnode)
{
- newnode->cost = from->cost;
- newnode->plan_size = from->plan_size;
+ newnode->startup_cost = from->startup_cost;
+ newnode->total_cost = from->total_cost;
+ newnode->plan_rows = from->plan_rows;
newnode->plan_width = from->plan_width;
- newnode->plan_tupperpage = from->plan_tupperpage;
- newnode->targetlist = copyObject(from->targetlist);
- newnode->qual = copyObject(from->qual);
- newnode->lefttree = copyObject(from->lefttree);
- newnode->righttree = copyObject(from->righttree);
+ /* 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);
- if (from->subPlan != NULL)
- newnode->subPlan = SS_pull_subplan((Node *) newnode->qual);
+ /* 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 = NULL;
+ newnode->subPlan = NIL;
newnode->nParamExec = from->nParamExec;
}
{
Plan *newnode = makeNode(Plan);
- /* ----------------
- * copy the node superclass fields
- * ----------------
+ /*
+ * copy the node superclass fields
*/
CopyPlanFields(from, newnode);
{
Result *newnode = makeNode(Result);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
Node_Copy(from, newnode, resconstantqual);
* We must add subplans in resconstantqual to the new plan's subPlan
* list
*/
- newnode->plan.subPlan = nconc(newnode->plan.subPlan,
- SS_pull_subplan(newnode->resconstantqual));
+ if (from->plan.subPlan != NIL)
+ newnode->plan.subPlan = nconc(newnode->plan.subPlan,
+ pull_subplans(newnode->resconstantqual));
return newnode;
}
{
Append *newnode = makeNode(Append);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
Node_Copy(from, newnode, appendplans);
- Node_Copy(from, newnode, unionrtables);
- newnode->inheritrelid = from->inheritrelid;
- Node_Copy(from, newnode, inheritrtable);
+ newnode->isTarget = from->isTarget;
return newnode;
}
{
Scan *newnode = makeNode(Scan);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
CopyScanFields((Scan *) from, (Scan *) newnode);
{
SeqScan *newnode = makeNode(SeqScan);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
CopyScanFields((Scan *) from, (Scan *) newnode);
{
IndexScan *newnode = makeNode(IndexScan);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
CopyScanFields((Scan *) from, (Scan *) newnode);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
newnode->indxid = listCopy(from->indxid);
Node_Copy(from, newnode, indxqual);
Node_Copy(from, newnode, indxqualorig);
newnode->indxorderdir = from->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));
+ }
+
+ return newnode;
+}
+
+/* ----------------
+ * _copyTidScan
+ * ----------------
+ */
+static TidScan *
+_copyTidScan(TidScan *from)
+{
+ TidScan *newnode = makeNode(TidScan);
+
+ /*
+ * 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);
+
+ return newnode;
+}
+
+/* ----------------
+ * _copySubqueryScan
+ * ----------------
+ */
+static SubqueryScan *
+_copySubqueryScan(SubqueryScan *from)
+{
+ SubqueryScan *newnode = makeNode(SubqueryScan);
+
+ /*
+ * copy node superclass fields
+ */
+ CopyPlanFields((Plan *) from, (Plan *) newnode);
+ CopyScanFields((Scan *) from, (Scan *) newnode);
+
+ /*
+ * copy remainder of node
+ */
+ Node_Copy(from, newnode, subplan);
+
+ return newnode;
+}
+
+/* ----------------
+ * _copyFunctionScan
+ * ----------------
+ */
+static FunctionScan *
+_copyFunctionScan(FunctionScan *from)
+{
+ FunctionScan *newnode = makeNode(FunctionScan);
+
+ /*
+ * copy node superclass fields
+ */
+ CopyPlanFields((Plan *) from, (Plan *) newnode);
+ CopyScanFields((Scan *) from, (Scan *) newnode);
+
return newnode;
}
static void
CopyJoinFields(Join *from, Join *newnode)
{
- /* nothing extra */
- return;
+ newnode->jointype = from->jointype;
+ Node_Copy(from, newnode, 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));
}
{
Join *newnode = makeNode(Join);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
CopyJoinFields(from, newnode);
{
NestLoop *newnode = makeNode(NestLoop);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
CopyJoinFields((Join *) from, (Join *) newnode);
{
MergeJoin *newnode = makeNode(MergeJoin);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
CopyJoinFields((Join *) from, (Join *) newnode);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
Node_Copy(from, newnode, 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));
+
return newnode;
}
{
HashJoin *newnode = makeNode(HashJoin);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
CopyJoinFields((Join *) from, (Join *) newnode);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
Node_Copy(from, newnode, hashclauses);
-
newnode->hashjoinop = from->hashjoinop;
- return newnode;
-}
-
-
-/* ----------------
- * CopyNonameFields
- *
- * This function copies the fields of the Noname node. It is used by
- * all the copy functions for classes which inherit from Noname.
- * ----------------
- */
-static void
-CopyNonameFields(Noname *from, Noname *newnode)
-{
- newnode->nonameid = from->nonameid;
- newnode->keycount = from->keycount;
- return;
-}
-
-
-/* ----------------
- * _copyNoname
- * ----------------
- */
-static Noname *
-_copyNoname(Noname *from)
-{
- Noname *newnode = makeNode(Noname);
-
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * We must add subplans in hashclauses to the new plan's subPlan list
*/
- CopyPlanFields((Plan *) from, (Plan *) newnode);
- CopyNonameFields(from, newnode);
+ if (from->join.plan.subPlan != NIL)
+ newnode->join.plan.subPlan = nconc(newnode->join.plan.subPlan,
+ pull_subplans((Node *) newnode->hashclauses));
return newnode;
}
+
/* ----------------
* _copyMaterial
* ----------------
{
Material *newnode = makeNode(Material);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
- CopyNonameFields((Noname *) from, (Noname *) newnode);
return newnode;
}
{
Sort *newnode = makeNode(Sort);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
- CopyNonameFields((Noname *) from, (Noname *) newnode);
+
+ newnode->keycount = from->keycount;
return newnode;
}
return newnode;
}
-
/* ----------------
* _copyUnique
* ----------------
{
Unique *newnode = makeNode(Unique);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
- CopyNonameFields((Noname *) from, (Noname *) newnode);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
- if (from->uniqueAttr)
- newnode->uniqueAttr = pstrdup(from->uniqueAttr);
- else
- newnode->uniqueAttr = NULL;
- newnode->uniqueAttrNum = from->uniqueAttrNum;
+ newnode->numCols = from->numCols;
+ newnode->uniqColIdx = palloc(from->numCols * sizeof(AttrNumber));
+ memcpy(newnode->uniqColIdx, from->uniqColIdx, from->numCols * sizeof(AttrNumber));
+
+ return newnode;
+}
+
+/* ----------------
+ * _copySetOp
+ * ----------------
+ */
+static SetOp *
+_copySetOp(SetOp *from)
+{
+ SetOp *newnode = makeNode(SetOp);
+
+ /*
+ * copy node superclass fields
+ */
+ CopyPlanFields((Plan *) from, (Plan *) newnode);
+
+ /*
+ * 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;
return newnode;
}
+/* ----------------
+ * _copyLimit
+ * ----------------
+ */
+static Limit *
+_copyLimit(Limit *from)
+{
+ Limit *newnode = makeNode(Limit);
+
+ /*
+ * copy node superclass fields
+ */
+ CopyPlanFields((Plan *) from, (Plan *) newnode);
+
+ /*
+ * copy remainder of node
+ */
+ Node_Copy(from, newnode, limitOffset);
+ Node_Copy(from, newnode, limitCount);
+
+ return newnode;
+}
/* ----------------
* _copyHash
{
Hash *newnode = makeNode(Hash);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
Node_Copy(from, newnode, hashkey);
newnode->parParam = listCopy(from->parParam);
Node_Copy(from, newnode, sublink);
+ /* do not copy execution state */
+ newnode->needShutdown = false;
+ newnode->curTuple = NULL;
+
return newnode;
}
{
Fjoin *newnode = makeNode(Fjoin);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
newnode->fj_initialized = from->fj_initialized;
{
Expr *newnode = makeNode(Expr);
- /* ----------------
- * copy node superclass fields
- * ----------------
+ /*
+ * copy node superclass fields
*/
newnode->typeOid = from->typeOid;
newnode->opType = from->opType;
{
Var *newnode = makeNode(Var);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
newnode->varno = from->varno;
newnode->varattno = from->varattno;
{
Oper *newnode = makeNode(Oper);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
newnode->opno = from->opno;
newnode->opid = from->opid;
newnode->opresulttype = from->opresulttype;
- newnode->opsize = from->opsize;
-
- /*
- * NOTE: shall we copy the cache structure or just the pointer ?
- * Alternatively we can set 'op_fcache' to NULL, in which case the
- * executor will initialize it when it needs it...
- */
- newnode->op_fcache = from->op_fcache;
+ newnode->opretset = from->opretset;
+ /* Do not copy the run-time state, if any */
+ newnode->op_fcache = NULL;
return newnode;
}
{
Const *newnode = makeNode(Const);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
newnode->consttype = from->consttype;
newnode->constlen = from->constlen;
if (from->constbyval || from->constisnull)
{
- /* ----------------
- * passed by value so just copy the datum.
- * Also, don't try to copy struct when value is null!
- * ----------------
+ /*
+ * passed by value so just copy the datum. Also, don't try to copy
+ * struct when value is null!
+ *
*/
newnode->constvalue = from->constvalue;
}
else
{
- /* ----------------
- * not passed by value. datum contains a pointer.
- * ----------------
+ /*
+ * not passed by value. datum contains a pointer.
*/
int length = from->constlen;
{
Param *newnode = makeNode(Param);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * 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;
- Node_Copy(from, newnode, param_tlist);
return newnode;
}
{
Func *newnode = makeNode(Func);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
newnode->funcid = from->funcid;
- newnode->functype = from->functype;
- newnode->funcisindex = from->funcisindex;
- newnode->funcsize = from->funcsize;
- newnode->func_fcache = from->func_fcache;
- Node_Copy(from, newnode, func_tlist);
- Node_Copy(from, newnode, func_planlist);
+ newnode->funcresulttype = from->funcresulttype;
+ newnode->funcretset = from->funcretset;
+ /* Do not copy the run-time state, if any */
+ newnode->func_fcache = NULL;
return newnode;
}
{
Aggref *newnode = makeNode(Aggref);
- /* ----------------
- * copy remainder of node
- * ----------------
- */
- newnode->aggname = pstrdup(from->aggname);
- newnode->basetype = from->basetype;
+ newnode->aggfnoid = from->aggfnoid;
newnode->aggtype = from->aggtype;
Node_Copy(from, newnode, target);
- newnode->usenulls = from->usenulls;
- newnode->aggno = from->aggno; /* probably not needed */
+ newnode->aggstar = from->aggstar;
+ newnode->aggdistinct = from->aggdistinct;
+ newnode->aggno = from->aggno; /* probably not needed */
return newnode;
}
{
SubLink *newnode = makeNode(SubLink);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
newnode->subLinkType = from->subLinkType;
newnode->useor = from->useor;
}
/* ----------------
+ * _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;
+
+ return newnode;
+}
+
+/* ----------------
+ * _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;
+
+ return newnode;
+}
+
+static RangeTblRef *
+_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);
+
+ return newnode;
+}
+
+static JoinExpr *
+_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;
+}
+
+/* ----------------
* _copyCaseExpr
* ----------------
*/
{
CaseExpr *newnode = makeNode(CaseExpr);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
newnode->casetype = from->casetype;
{
CaseWhen *newnode = makeNode(CaseWhen);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
Node_Copy(from, newnode, expr);
Node_Copy(from, newnode, result);
return newnode;
}
-static Array *
-_copyArray(Array *from)
+/* ----------------
+ * _copyNullTest
+ * ----------------
+ */
+static NullTest *
+_copyNullTest(NullTest *from)
+{
+ NullTest *newnode = makeNode(NullTest);
+
+ /*
+ * copy remainder of node
+ */
+ Node_Copy(from, newnode, arg);
+ newnode->nulltesttype = from->nulltesttype;
+
+ return newnode;
+}
+
+/* ----------------
+ * _copyBooleanTest
+ * ----------------
+ */
+static BooleanTest *
+_copyBooleanTest(BooleanTest *from)
{
- Array *newnode = makeNode(Array);
+ BooleanTest *newnode = makeNode(BooleanTest);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
- newnode->arrayelemtype = from->arrayelemtype;
- newnode->arrayelemlength = from->arrayelemlength;
- newnode->arrayelembyval = from->arrayelembyval;
- newnode->arrayndim = from->arrayndim;
- newnode->arraylow = from->arraylow;
- newnode->arrayhigh = from->arrayhigh;
- newnode->arraylen = from->arraylen;
+ Node_Copy(from, newnode, arg);
+ newnode->booltesttype = from->booltesttype;
return newnode;
}
{
ArrayRef *newnode = makeNode(ArrayRef);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
newnode->refattrlength = from->refattrlength;
newnode->refelemlength = from->refelemlength;
* _copyRelOptInfo
* ----------------
*/
-/*
- * when you change this, also make sure to fix up xfunc_copyRelOptInfo in
- * planner/path/xfunc.c accordingly!!!
- * -- JMH, 8/2/93
- */
static RelOptInfo *
_copyRelOptInfo(RelOptInfo *from)
{
RelOptInfo *newnode = makeNode(RelOptInfo);
- int i,
- len;
- /* ----------------
- * copy remainder of node
- * ----------------
- */
+ newnode->reloptkind = from->reloptkind;
+
newnode->relids = listCopy(from->relids);
- newnode->indexed = from->indexed;
- newnode->pages = from->pages;
- newnode->tuples = from->tuples;
- newnode->size = from->size;
+ newnode->rows = from->rows;
newnode->width = from->width;
+
Node_Copy(from, newnode, targetlist);
Node_Copy(from, newnode, pathlist);
- Node_Copy(from, newnode, cheapestpath);
+ /* 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);
+ Node_Copy(from, newnode, innerjoin);
+
+ return newnode;
+}
+
+/* ----------------
+ * _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;
+
if (from->classlist)
{
- for (len = 0; from->classlist[len] != 0; len++)
- ;
- newnode->classlist = (Oid *) palloc(sizeof(Oid) * (len + 1));
- for (i = 0; i < len; i++)
- newnode->classlist[i] = from->classlist[i];
- newnode->classlist[len] = 0;
+ /* copy the trailing zero too */
+ len = (from->ncolumns + 1) * sizeof(Oid);
+ newnode->classlist = (Oid *) palloc(len);
+ memcpy(newnode->classlist, from->classlist, len);
}
if (from->indexkeys)
{
- for (len = 0; from->indexkeys[len] != 0; len++)
- ;
- newnode->indexkeys = (int *) palloc(sizeof(int) * (len + 1));
- for (i = 0; i < len; i++)
- newnode->indexkeys[i] = from->indexkeys[i];
- newnode->indexkeys[len] = 0;
+ /* copy the trailing zero too */
+ len = (from->nkeys + 1) * sizeof(int);
+ newnode->indexkeys = (int *) palloc(len);
+ memcpy(newnode->indexkeys, from->indexkeys, len);
}
if (from->ordering)
{
- for (len = 0; from->ordering[len] != 0; len++)
- ;
- newnode->ordering = (Oid *) palloc(sizeof(Oid) * (len + 1));
- for (i = 0; i < len; i++)
- newnode->ordering[i] = from->ordering[i];
- newnode->ordering[len] = 0;
+ /* copy the trailing zero too */
+ len = (from->ncolumns + 1) * sizeof(Oid);
+ newnode->ordering = (Oid *) palloc(len);
+ memcpy(newnode->ordering, from->ordering, len);
}
newnode->relam = from->relam;
+ newnode->amcostestimate = from->amcostestimate;
newnode->indproc = from->indproc;
Node_Copy(from, newnode, indpred);
-
- Node_Copy(from, newnode, restrictinfo);
- Node_Copy(from, newnode, joininfo);
- Node_Copy(from, newnode, innerjoin);
+ newnode->unique = from->unique;
return newnode;
}
*/
newnode->parent = from->parent;
- newnode->path_cost = from->path_cost;
+ newnode->startup_cost = from->startup_cost;
+ newnode->total_cost = from->total_cost;
newnode->pathtype = from->pathtype;
{
IndexPath *newnode = makeNode(IndexPath);
- /* ----------------
- * copy the node superclass fields
- * ----------------
+ /*
+ * copy the node superclass fields
*/
CopyPathFields((Path *) from, (Path *) newnode);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
- newnode->indexid = listCopy(from->indexid);
+ Node_Copy(from, newnode, indexinfo);
Node_Copy(from, newnode, indexqual);
+ newnode->indexscandir = from->indexscandir;
newnode->joinrelids = listCopy(from->joinrelids);
+ newnode->alljoinquals = from->alljoinquals;
+ newnode->rows = from->rows;
return newnode;
}
/* ----------------
- * CopyJoinPathFields
- *
- * This function copies the fields of the JoinPath node. It is used by
- * all the copy functions for classes which inherit from JoinPath.
+ * _copyTidPath
* ----------------
*/
-static void
-CopyJoinPathFields(JoinPath *from, JoinPath *newnode)
+static TidPath *
+_copyTidPath(TidPath *from)
{
- Node_Copy(from, newnode, pathinfo);
- Node_Copy(from, newnode, outerjoinpath);
- Node_Copy(from, newnode, innerjoinpath);
-}
+ TidPath *newnode = makeNode(TidPath);
-/* ----------------
- * _copyNestPath
+ /*
+ * copy the node superclass fields
+ */
+ CopyPathFields((Path *) from, (Path *) newnode);
+
+ /*
+ * copy remainder of node
+ */
+ Node_Copy(from, newnode, tideval);
+ newnode->unjoined_relids = listCopy(from->unjoined_relids);
+
+ return newnode;
+}
+
+/* ----------------
+ * _copyAppendPath
+ * ----------------
+ */
+static AppendPath *
+_copyAppendPath(AppendPath *from)
+{
+ AppendPath *newnode = makeNode(AppendPath);
+
+ /*
+ * copy the node superclass fields
+ */
+ CopyPathFields((Path *) from, (Path *) newnode);
+
+ /*
+ * copy remainder of node
+ */
+ Node_Copy(from, newnode, subpaths);
+
+ return newnode;
+}
+
+/* ----------------
+ * 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);
+}
+
+/* ----------------
+ * _copyNestPath
* ----------------
*/
static NestPath *
{
NestPath *newnode = makeNode(NestPath);
- /* ----------------
- * copy the node superclass fields
- * ----------------
+ /*
+ * copy the node superclass fields
*/
CopyPathFields((Path *) from, (Path *) newnode);
CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
{
MergePath *newnode = makeNode(MergePath);
- /* ----------------
- * copy the node superclass fields
- * ----------------
+ /*
+ * copy the node superclass fields
*/
CopyPathFields((Path *) from, (Path *) newnode);
CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
- /* ----------------
- * copy the remainder of the node
- * ----------------
+ /*
+ * copy the remainder of the node
*/
Node_Copy(from, newnode, path_mergeclauses);
Node_Copy(from, newnode, outersortkeys);
{
HashPath *newnode = makeNode(HashPath);
- /* ----------------
- * copy the node superclass fields
- * ----------------
+ /*
+ * copy the node superclass fields
*/
CopyPathFields((Path *) from, (Path *) newnode);
CopyJoinPathFields((JoinPath *) from, (JoinPath *) newnode);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
Node_Copy(from, newnode, path_hashclauses);
static PathKeyItem *
_copyPathKeyItem(PathKeyItem *from)
{
- PathKeyItem *newnode = makeNode(PathKeyItem);
+ PathKeyItem *newnode = makeNode(PathKeyItem);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
Node_Copy(from, newnode, key);
newnode->sortop = from->sortop;
{
RestrictInfo *newnode = makeNode(RestrictInfo);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
Node_Copy(from, newnode, clause);
- newnode->selectivity = from->selectivity;
+ 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;
+
+ /*
+ * Do not copy pathkeys, since they'd not be canonical in a copied
+ * query
+ */
+ 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;
return newnode;
}
{
JoinInfo *newnode = makeNode(JoinInfo);
- /* ----------------
- * copy remainder of node
- * ----------------
+ /*
+ * copy remainder of node
*/
newnode->unjoined_relids = listCopy(from->unjoined_relids);
Node_Copy(from, newnode, jinfo_restrictinfo);
return newnode;
}
-static Iter *
-_copyIter(Iter *from)
-{
- Iter *newnode = makeNode(Iter);
-
- Node_Copy(from, newnode, iterexpr);
- newnode->itertype = from->itertype;
-
- return newnode;
-}
-
static Stream *
_copyStream(Stream *from)
{
if (newnode->downstream)
((Stream *) newnode->downstream)->upstream = (Stream *) newnode;
- newnode->groupup = from->groupup;
- newnode->groupcost = from->groupcost;
- newnode->groupsel = from->groupsel;
+ newnode->groupup = from->groupup;
+ newnode->groupcost = from->groupcost;
+ newnode->groupsel = from->groupsel;
+
+ return newnode;
+}
+
+/* ****************************************************************
+ * parsenodes.h copy functions
+ * ****************************************************************
+ */
+
+static TargetEntry *
+_copyTargetEntry(TargetEntry *from)
+{
+ TargetEntry *newnode = makeNode(TargetEntry);
+
+ Node_Copy(from, newnode, resdom);
+ Node_Copy(from, newnode, fjoin);
+ Node_Copy(from, newnode, expr);
+ return newnode;
+}
+
+static RangeTblEntry *
+_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);
+ 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;
+
+ return newnode;
+}
+
+static FkConstraint *
+_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);
+ if (from->match_type)
+ newnode->match_type = pstrdup(from->match_type);
+ newnode->actions = from->actions;
+ newnode->deferrable = from->deferrable;
+ newnode->initdeferred = from->initdeferred;
+
+ return newnode;
+}
+
+static SortClause *
+_copySortClause(SortClause *from)
+{
+ SortClause *newnode = makeNode(SortClause);
+
+ newnode->tleSortGroupRef = from->tleSortGroupRef;
+ newnode->sortop = from->sortop;
+
+ return newnode;
+}
+
+static A_Expr *
+_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);
+
+ return newnode;
+}
+
+static ColumnRef *
+_copyColumnRef(ColumnRef *from)
+{
+ ColumnRef *newnode = makeNode(ColumnRef);
+
+ Node_Copy(from, newnode, fields);
+ Node_Copy(from, newnode, indirection);
+
+ return newnode;
+}
+
+static ParamRef *
+_copyParamRef(ParamRef *from)
+{
+ ParamRef *newnode = makeNode(ParamRef);
+
+ newnode->number = from->number;
+ Node_Copy(from, newnode, fields);
+ Node_Copy(from, newnode, indirection);
+
+ return newnode;
+}
+
+static A_Const *
+_copyAConst(A_Const *from)
+{
+ A_Const *newnode = makeNode(A_Const);
+
+ newnode->val = *((Value *) (copyObject(&(from->val))));
+ Node_Copy(from, newnode, typename);
+
+ return newnode;
+}
+
+static Ident *
+_copyIdent(Ident *from)
+{
+ Ident *newnode = makeNode(Ident);
+
+ newnode->name = pstrdup(from->name);
+
+ return newnode;
+}
+
+static FuncCall *
+_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;
+
+ return newnode;
+}
+
+static A_Indices *
+_copyAIndices(A_Indices *from)
+{
+ A_Indices *newnode = makeNode(A_Indices);
+
+ Node_Copy(from, newnode, lidx);
+ Node_Copy(from, newnode, uidx);
+
+ return newnode;
+}
+
+static ExprFieldSelect *
+_copyExprFieldSelect(ExprFieldSelect *from)
+{
+ ExprFieldSelect *newnode = makeNode(ExprFieldSelect);
+
+ Node_Copy(from, newnode, arg);
+ Node_Copy(from, newnode, fields);
+ Node_Copy(from, newnode, indirection);
+
+ return newnode;
+}
+
+static ResTarget *
+_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);
+
+ return newnode;
+}
+
+static TypeName *
+_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);
+
+ return newnode;
+}
+
+static SortGroupBy *
+_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);
+
+ return newnode;
+}
+
+static RangeSubselect *
+_copyRangeSubselect(RangeSubselect *from)
+{
+ RangeSubselect *newnode = makeNode(RangeSubselect);
+
+ Node_Copy(from, newnode, subquery);
+ Node_Copy(from, newnode, alias);
+
+ return newnode;
+}
+
+static RangeFunction *
+_copyRangeFunction(RangeFunction *from)
+{
+ RangeFunction *newnode = makeNode(RangeFunction);
+
+ Node_Copy(from, newnode, funccallnode);
+ Node_Copy(from, newnode, alias);
+
+ return newnode;
+}
+
+static TypeCast *
+_copyTypeCast(TypeCast *from)
+{
+ TypeCast *newnode = makeNode(TypeCast);
+
+ Node_Copy(from, newnode, arg);
+ Node_Copy(from, newnode, typename);
+
+ return newnode;
+}
+
+static IndexElem *
+_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);
+
+ return newnode;
+}
+
+static ColumnDef *
+_copyColumnDef(ColumnDef *from)
+{
+ ColumnDef *newnode = makeNode(ColumnDef);
+
+ if (from->colname)
+ newnode->colname = pstrdup(from->colname);
+ Node_Copy(from, newnode, typename);
+ 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);
+
+ return newnode;
+}
+
+static Constraint *
+_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);
+
+ return newnode;
+}
+
+static DefElem *
+_copyDefElem(DefElem *from)
+{
+ DefElem *newnode = makeNode(DefElem);
+
+ if (from->defname)
+ newnode->defname = pstrdup(from->defname);
+ Node_Copy(from, newnode, arg);
+
+ return newnode;
+}
+
+static Query *
+_copyQuery(Query *from)
+{
+ Query *newnode = makeNode(Query);
+
+ newnode->commandType = from->commandType;
+ 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;
+ newnode->originalQuery = from->originalQuery;
+
+ Node_Copy(from, newnode, rtable);
+ Node_Copy(from, newnode, jointree);
+
+ newnode->rowMarks = listCopy(from->rowMarks);
+
+ Node_Copy(from, newnode, targetList);
+
+ Node_Copy(from, newnode, groupClause);
+ Node_Copy(from, newnode, havingQual);
+ Node_Copy(from, newnode, distinctClause);
+ Node_Copy(from, newnode, sortClause);
+
+ Node_Copy(from, newnode, limitOffset);
+ Node_Copy(from, newnode, limitCount);
+
+ Node_Copy(from, newnode, setOperations);
+
+ newnode->resultRelations = listCopy(from->resultRelations);
+
+ /*
+ * We do not copy the planner internal fields: base_rel_list,
+ * other_rel_list, join_rel_list, equi_key_list, query_pathkeys. Not
+ * entirely clear if this is right?
+ */
+
+ return newnode;
+}
+
+static InsertStmt *
+_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);
+
+ return newnode;
+}
+
+static DeleteStmt *
+_copyDeleteStmt(DeleteStmt *from)
+{
+ DeleteStmt *newnode = makeNode(DeleteStmt);
+
+ Node_Copy(from, newnode, relation);
+ Node_Copy(from, newnode, whereClause);
+
+ return newnode;
+}
+
+static UpdateStmt *
+_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);
+
+ return newnode;
+}
+
+static SelectStmt *
+_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);
+
+ return newnode;
+}
+
+static SetOperationStmt *
+_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);
+
+ return newnode;
+}
+
+static AlterTableStmt *
+_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;
+
+ return newnode;
+}
+
+static GrantStmt *
+_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);
+
+ return newnode;
+}
+
+static PrivGrantee *
+_copyPrivGrantee(PrivGrantee *from)
+{
+ PrivGrantee *newnode = makeNode(PrivGrantee);
+
+ if (from->username)
+ newnode->username = pstrdup(from->username);
+ if (from->groupname)
+ newnode->groupname = pstrdup(from->groupname);
+
+ return newnode;
+}
+
+static FuncWithArgs *
+_copyFuncWithArgs(FuncWithArgs *from)
+{
+ FuncWithArgs *newnode = makeNode(FuncWithArgs);
+
+ Node_Copy(from, newnode, funcname);
+ Node_Copy(from, newnode, funcargs);
+
+ return newnode;
+}
+
+static InsertDefault *
+_copyInsertDefault(InsertDefault *from)
+{
+ InsertDefault *newnode = makeNode(InsertDefault);
+
+ return newnode;
+}
+
+
+static ClosePortalStmt *
+_copyClosePortalStmt(ClosePortalStmt *from)
+{
+ ClosePortalStmt *newnode = makeNode(ClosePortalStmt);
+
+ if (from->portalname)
+ newnode->portalname = pstrdup(from->portalname);
+
+ return newnode;
+}
+
+static ClusterStmt *
+_copyClusterStmt(ClusterStmt *from)
+{
+ ClusterStmt *newnode = makeNode(ClusterStmt);
+
+ Node_Copy(from, newnode, relation);
+ if (from->indexname)
+ newnode->indexname = pstrdup(from->indexname);
+
+ return newnode;
+}
+
+static CopyStmt *
+_copyCopyStmt(CopyStmt *from)
+{
+ CopyStmt *newnode = makeNode(CopyStmt);
+
+ Node_Copy(from, newnode, relation);
+ newnode->is_from = from->is_from;
+ if (from->filename)
+ newnode->filename = pstrdup(from->filename);
+ Node_Copy(from, newnode, options);
+
+ return newnode;
+}
+
+static CreateStmt *
+_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;
+
+ return newnode;
+}
+
+static DefineStmt *
+_copyDefineStmt(DefineStmt *from)
+{
+ DefineStmt *newnode = makeNode(DefineStmt);
+
+ newnode->defType = from->defType;
+ Node_Copy(from, newnode, defnames);
+ Node_Copy(from, newnode, definition);
+
+ return newnode;
+}
+
+static DropStmt *
+_copyDropStmt(DropStmt *from)
+{
+ DropStmt *newnode = makeNode(DropStmt);
+
+ Node_Copy(from, newnode, objects);
+ newnode->removeType = from->removeType;
+ newnode->behavior = from->behavior;
+
+ return newnode;
+}
+
+static TruncateStmt *
+_copyTruncateStmt(TruncateStmt *from)
+{
+ TruncateStmt *newnode = makeNode(TruncateStmt);
+
+ Node_Copy(from, newnode, relation);
+
+ return newnode;
+}
+
+static CommentStmt *
+_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);
+
+ return newnode;
+}
+
+static FetchStmt *
+_copyFetchStmt(FetchStmt *from)
+{
+ FetchStmt *newnode = makeNode(FetchStmt);
+
+ newnode->direction = from->direction;
+ newnode->howMany = from->howMany;
+ newnode->portalname = pstrdup(from->portalname);
+ newnode->ismove = from->ismove;
+
+ return newnode;
+}
+
+static IndexStmt *
+_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;
+
+ return newnode;
+}
+
+static CreateFunctionStmt *
+_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);
+
+ return newnode;
+}
+
+static RemoveAggrStmt *
+_copyRemoveAggrStmt(RemoveAggrStmt *from)
+{
+ RemoveAggrStmt *newnode = makeNode(RemoveAggrStmt);
+
+ Node_Copy(from, newnode, aggname);
+ Node_Copy(from, newnode, aggtype);
+ newnode->behavior = from->behavior;
+
+ return newnode;
+}
+
+static RemoveFuncStmt *
+_copyRemoveFuncStmt(RemoveFuncStmt *from)
+{
+ RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
+
+ Node_Copy(from, newnode, funcname);
+ Node_Copy(from, newnode, args);
+ newnode->behavior = from->behavior;
+
+ return newnode;
+}
+
+static RemoveOperStmt *
+_copyRemoveOperStmt(RemoveOperStmt *from)
+{
+ RemoveOperStmt *newnode = makeNode(RemoveOperStmt);
+
+ Node_Copy(from, newnode, opname);
+ Node_Copy(from, newnode, args);
+ newnode->behavior = from->behavior;
+
+ return newnode;
+}
+
+static RenameStmt *
+_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;
+
+ return newnode;
+}
+
+static RuleStmt *
+_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;
+ Node_Copy(from, newnode, actions);
+
+ return newnode;
+}
+
+static NotifyStmt *
+_copyNotifyStmt(NotifyStmt *from)
+{
+ NotifyStmt *newnode = makeNode(NotifyStmt);
+
+ Node_Copy(from, newnode, relation);
+
+ return newnode;
+}
+
+static ListenStmt *
+_copyListenStmt(ListenStmt *from)
+{
+ ListenStmt *newnode = makeNode(ListenStmt);
+
+ Node_Copy(from, newnode, relation);
+
+ return newnode;
+}
+
+static UnlistenStmt *
+_copyUnlistenStmt(UnlistenStmt *from)
+{
+ UnlistenStmt *newnode = makeNode(UnlistenStmt);
+
+ Node_Copy(from, newnode, relation);
+
+ return newnode;
+}
+
+static TransactionStmt *
+_copyTransactionStmt(TransactionStmt *from)
+{
+ TransactionStmt *newnode = makeNode(TransactionStmt);
+
+ newnode->command = from->command;
+
+ return newnode;
+}
+
+static ViewStmt *
+_copyViewStmt(ViewStmt *from)
+{
+ ViewStmt *newnode = makeNode(ViewStmt);
+
+ Node_Copy(from, newnode, view);
+ Node_Copy(from, newnode, aliases);
+ Node_Copy(from, newnode, query);
+
+ return newnode;
+}
+
+static LoadStmt *
+_copyLoadStmt(LoadStmt *from)
+{
+ LoadStmt *newnode = makeNode(LoadStmt);
+
+ if (from->filename)
+ newnode->filename = pstrdup(from->filename);
+
+ return newnode;
+}
+
+static CreateDomainStmt *
+_copyCreateDomainStmt(CreateDomainStmt *from)
+{
+ CreateDomainStmt *newnode = makeNode(CreateDomainStmt);
+
+ Node_Copy(from, newnode, domainname);
+ Node_Copy(from, newnode, typename);
+ Node_Copy(from, newnode, constraints);
+
+ return newnode;
+}
+
+static CreatedbStmt *
+_copyCreatedbStmt(CreatedbStmt *from)
+{
+ CreatedbStmt *newnode = makeNode(CreatedbStmt);
+
+ if (from->dbname)
+ newnode->dbname = pstrdup(from->dbname);
+ Node_Copy(from, newnode, options);
+
+ return newnode;
+}
+
+static AlterDatabaseSetStmt *
+_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);
+
+ return newnode;
+}
+
+static DropdbStmt *
+_copyDropdbStmt(DropdbStmt *from)
+{
+ DropdbStmt *newnode = makeNode(DropdbStmt);
+
+ if (from->dbname)
+ newnode->dbname = pstrdup(from->dbname);
+
+ return newnode;
+}
+
+static VacuumStmt *
+_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);
+
+ return newnode;
+}
+
+static ExplainStmt *
+_copyExplainStmt(ExplainStmt *from)
+{
+ ExplainStmt *newnode = makeNode(ExplainStmt);
+
+ Node_Copy(from, newnode, query);
+ newnode->verbose = from->verbose;
+ newnode->analyze = from->analyze;
+
+ return newnode;
+}
+
+static CreateSeqStmt *
+_copyCreateSeqStmt(CreateSeqStmt *from)
+{
+ CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
+
+ Node_Copy(from, newnode, sequence);
+ Node_Copy(from, newnode, options);
+
+ return newnode;
+}
+
+static VariableSetStmt *
+_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;
+
+ return newnode;
+}
+
+static VariableShowStmt *
+_copyVariableShowStmt(VariableShowStmt *from)
+{
+ VariableShowStmt *newnode = makeNode(VariableShowStmt);
+
+ if (from->name)
+ newnode->name = pstrdup(from->name);
+
+ return newnode;
+}
+
+static VariableResetStmt *
+_copyVariableResetStmt(VariableResetStmt *from)
+{
+ VariableResetStmt *newnode = makeNode(VariableResetStmt);
+
+ if (from->name)
+ newnode->name = pstrdup(from->name);
+
+ return newnode;
+}
+
+static CreateTrigStmt *
+_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));
+ if (from->lang)
+ newnode->lang = pstrdup(from->lang);
+ if (from->text)
+ newnode->text = pstrdup(from->text);
+
+ Node_Copy(from, newnode, attr);
+ if (from->when)
+ newnode->when = pstrdup(from->when);
+ newnode->isconstraint = from->isconstraint;
+ newnode->deferrable = from->deferrable;
+ newnode->initdeferred = from->initdeferred;
+ Node_Copy(from, newnode, constrrel);
+
+ return newnode;
+}
+
+static DropPropertyStmt *
+_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;
+
+ return newnode;
+}
+
+static CreatePLangStmt *
+_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);
+ if (from->plcompiler)
+ newnode->plcompiler = pstrdup(from->plcompiler);
+ newnode->pltrusted = from->pltrusted;
+
+ return newnode;
+}
+
+static DropPLangStmt *
+_copyDropPLangStmt(DropPLangStmt *from)
+{
+ DropPLangStmt *newnode = makeNode(DropPLangStmt);
+
+ if (from->plname)
+ newnode->plname = pstrdup(from->plname);
+ newnode->behavior = from->behavior;
return newnode;
}
-/*
- * parsenodes.h routines have no copy functions
- */
+static CreateUserStmt *
+_copyCreateUserStmt(CreateUserStmt *from)
+{
+ CreateUserStmt *newnode = makeNode(CreateUserStmt);
-static TargetEntry *
-_copyTargetEntry(TargetEntry *from)
+ if (from->user)
+ newnode->user = pstrdup(from->user);
+ Node_Copy(from, newnode, options);
+
+ return newnode;
+}
+
+static AlterUserStmt *
+_copyAlterUserStmt(AlterUserStmt *from)
{
- TargetEntry *newnode = makeNode(TargetEntry);
+ AlterUserStmt *newnode = makeNode(AlterUserStmt);
+
+ if (from->user)
+ newnode->user = pstrdup(from->user);
+ Node_Copy(from, newnode, options);
- Node_Copy(from, newnode, resdom);
- Node_Copy(from, newnode, fjoin);
- Node_Copy(from, newnode, expr);
return newnode;
}
-static RangeTblEntry *
-_copyRangeTblEntry(RangeTblEntry *from)
+static AlterUserSetStmt *
+_copyAlterUserSetStmt(AlterUserSetStmt *from)
{
- RangeTblEntry *newnode = makeNode(RangeTblEntry);
+ AlterUserSetStmt *newnode = makeNode(AlterUserSetStmt);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
- if (from->refname)
- newnode->refname = pstrdup(from->refname);
- newnode->relid = from->relid;
- newnode->inh = from->inh;
- newnode->inFromCl = from->inFromCl;
- newnode->inJoinSet = from->inJoinSet;
- newnode->skipAcl = from->skipAcl;
+ if (from->user)
+ newnode->user = pstrdup(from->user);
+ if (from->variable)
+ newnode->variable = pstrdup(from->variable);
+ Node_Copy(from, newnode, value);
return newnode;
}
-static RowMark *
-_copyRowMark(RowMark *from)
+static DropUserStmt *
+_copyDropUserStmt(DropUserStmt *from)
{
- RowMark *newnode = makeNode(RowMark);
+ DropUserStmt *newnode = makeNode(DropUserStmt);
- newnode->rti = from->rti;
- newnode->info = from->info;
+ Node_Copy(from, newnode, users);
return newnode;
}
-static SortClause *
-_copySortClause(SortClause *from)
+static LockStmt *
+_copyLockStmt(LockStmt *from)
{
- SortClause *newnode = makeNode(SortClause);
+ LockStmt *newnode = makeNode(LockStmt);
- newnode->tleSortGroupRef = from->tleSortGroupRef;
- newnode->sortop = from->sortop;
+ Node_Copy(from, newnode, relations);
+
+ newnode->mode = from->mode;
return newnode;
}
-static A_Const *
-_copyAConst(A_Const *from)
+static ConstraintsSetStmt *
+_copyConstraintsSetStmt(ConstraintsSetStmt *from)
{
- A_Const *newnode = makeNode(A_Const);
+ ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt);
- newnode->val = *((Value *) (copyObject(&(from->val))));
- Node_Copy(from, newnode, typename);
+ Node_Copy(from, newnode, constraints);
+ newnode->deferred = from->deferred;
return newnode;
}
-static TypeName *
-_copyTypeName(TypeName *from)
+static CreateGroupStmt *
+_copyCreateGroupStmt(CreateGroupStmt *from)
{
- TypeName *newnode = makeNode(TypeName);
+ CreateGroupStmt *newnode = makeNode(CreateGroupStmt);
if (from->name)
newnode->name = pstrdup(from->name);
- newnode->timezone = from->timezone;
- newnode->setof = from->setof;
- newnode->typmod = from->typmod;
- Node_Copy(from, newnode, arrayBounds);
+ Node_Copy(from, newnode, options);
return newnode;
}
-static Query *
-_copyQuery(Query *from)
+static AlterGroupStmt *
+_copyAlterGroupStmt(AlterGroupStmt *from)
{
- Query *newnode = makeNode(Query);
+ AlterGroupStmt *newnode = makeNode(AlterGroupStmt);
- newnode->commandType = from->commandType;
- if (from->utilityStmt && nodeTag(from->utilityStmt) == T_NotifyStmt)
- {
- NotifyStmt *from_notify = (NotifyStmt *) from->utilityStmt;
- NotifyStmt *n = makeNode(NotifyStmt);
+ if (from->name)
+ newnode->name = pstrdup(from->name);
+ newnode->action = from->action;
+ Node_Copy(from, newnode, listUsers);
- n->relname = pstrdup(from_notify->relname);
- newnode->utilityStmt = (Node *) n;
- }
- newnode->resultRelation = from->resultRelation;
- if (from->into)
- newnode->into = pstrdup(from->into);
- newnode->isPortal = from->isPortal;
- newnode->isBinary = from->isBinary;
- newnode->isTemp = from->isTemp;
- newnode->unionall = from->unionall;
- newnode->hasAggs = from->hasAggs;
- newnode->hasSubLinks = from->hasSubLinks;
+ return newnode;
+}
- Node_Copy(from, newnode, rtable);
- Node_Copy(from, newnode, targetList);
- Node_Copy(from, newnode, qual);
- Node_Copy(from, newnode, rowMark);
+static DropGroupStmt *
+_copyDropGroupStmt(DropGroupStmt *from)
+{
+ DropGroupStmt *newnode = makeNode(DropGroupStmt);
- if (from->uniqueFlag)
- newnode->uniqueFlag = pstrdup(from->uniqueFlag);
- Node_Copy(from, newnode, sortClause);
- Node_Copy(from, newnode, groupClause);
- Node_Copy(from, newnode, havingQual);
+ if (from->name)
+ newnode->name = pstrdup(from->name);
- /* why is intersectClause missing? */
- Node_Copy(from, newnode, unionClause);
+ return newnode;
+}
- Node_Copy(from, newnode, limitOffset);
- Node_Copy(from, newnode, limitCount);
+static ReindexStmt *
+_copyReindexStmt(ReindexStmt *from)
+{
+ ReindexStmt *newnode = makeNode(ReindexStmt);
- /* we do not copy the planner internal fields: base_rel_list,
- * join_rel_list, query_pathkeys. Not entirely clear if this is right?
- */
+ 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;
return newnode;
}
+static CreateSchemaStmt *
+_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);
+
+ return newnode;
+}
-/*
- * mnodes.h routines have no copy functions
- */
/* ****************************************************************
* pg_list.h copy functions
newnode->type = from->type;
switch (from->type)
{
- case T_String:
- newnode->val.str = pstrdup(from->val.str);
- break;
case T_Integer:
newnode->val.ival = from->val.ival;
break;
case T_Float:
- newnode->val.dval = from->val.dval;
+ case T_String:
+ case T_BitString:
+ newnode->val.str = pstrdup(from->val.str);
break;
default:
break;
if (from == NULL)
return NULL;
+
switch (nodeTag(from))
{
-
/*
* PLAN NODES
*/
case T_IndexScan:
retval = _copyIndexScan(from);
break;
+ case T_TidScan:
+ retval = _copyTidScan(from);
+ break;
+ case T_SubqueryScan:
+ retval = _copySubqueryScan(from);
+ break;
+ case T_FunctionScan:
+ retval = _copyFunctionScan(from);
+ break;
case T_Join:
retval = _copyJoin(from);
break;
case T_HashJoin:
retval = _copyHashJoin(from);
break;
- case T_Noname:
- retval = _copyNoname(from);
- break;
case T_Material:
retval = _copyMaterial(from);
break;
case T_Agg:
retval = _copyAgg(from);
break;
- case T_GroupClause:
- retval = _copyGroupClause(from);
- break;
case T_Unique:
retval = _copyUnique(from);
break;
+ case T_SetOp:
+ retval = _copySetOp(from);
+ break;
+ case T_Limit:
+ retval = _copyLimit(from);
+ break;
case T_Hash:
retval = _copyHash(from);
break;
case T_Param:
retval = _copyParam(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_Array:
- retval = _copyArray(from);
- break;
case T_ArrayRef:
retval = _copyArrayRef(from);
break;
- case T_Aggref:
- retval = _copyAggref(from);
+ case T_FieldSelect:
+ retval = _copyFieldSelect(from);
break;
- case T_SubLink:
- retval = _copySubLink(from);
+ case T_RelabelType:
+ retval = _copyRelabelType(from);
break;
- case T_CaseExpr:
- retval = _copyCaseExpr(from);
+ case T_RangeTblRef:
+ retval = _copyRangeTblRef(from);
break;
- case T_CaseWhen:
- retval = _copyCaseWhen(from);
+ case T_FromExpr:
+ retval = _copyFromExpr(from);
+ break;
+ case T_JoinExpr:
+ retval = _copyJoinExpr(from);
break;
/*
case T_IndexPath:
retval = _copyIndexPath(from);
break;
+ case T_TidPath:
+ retval = _copyTidPath(from);
+ break;
+ case T_AppendPath:
+ retval = _copyAppendPath(from);
+ break;
case T_NestPath:
retval = _copyNestPath(from);
break;
case T_JoinInfo:
retval = _copyJoinInfo(from);
break;
- case T_Iter:
- retval = _copyIter(from);
- break;
case T_Stream:
retval = _copyStream(from);
break;
-
- /*
- * PARSE NODES
- */
- case T_Query:
- retval = _copyQuery(from);
- break;
- case T_TargetEntry:
- retval = _copyTargetEntry(from);
- break;
- case T_RangeTblEntry:
- retval = _copyRangeTblEntry(from);
- break;
- case T_RowMark:
- retval = _copyRowMark(from);
- break;
- case T_SortClause:
- retval = _copySortClause(from);
- break;
- case T_A_Const:
- retval = _copyAConst(from);
- break;
- case T_TypeName:
- retval = _copyTypeName(from);
+ case T_IndexOptInfo:
+ retval = _copyIndexOptInfo(from);
break;
/*
* VALUE NODES
*/
case T_Integer:
- case T_String:
case T_Float:
+ case T_String:
+ case T_BitString:
retval = _copyValue(from);
break;
case T_List:
/* rather ugly coding for speed... */
/* Note the input list cannot be NIL if we got here. */
- nl = lcons(copyObject(lfirst(list)), NIL);
+ nl = makeList1(copyObject(lfirst(list)));
retval = nl;
foreach(l, lnext(list))
{
- lnext(nl) = lcons(copyObject(lfirst(l)), NIL);
+ lnext(nl) = makeList1(copyObject(lfirst(l)));
nl = lnext(nl);
}
}
break;
+
+ /*
+ * PARSE NODES
+ */
+ case T_Query:
+ retval = _copyQuery(from);
+ break;
+ case T_InsertStmt:
+ retval = _copyInsertStmt(from);
+ break;
+ case T_DeleteStmt:
+ retval = _copyDeleteStmt(from);
+ break;
+ case T_UpdateStmt:
+ retval = _copyUpdateStmt(from);
+ break;
+ case T_SelectStmt:
+ retval = _copySelectStmt(from);
+ break;
+ case T_SetOperationStmt:
+ retval = _copySetOperationStmt(from);
+ break;
+ case T_AlterTableStmt:
+ retval = _copyAlterTableStmt(from);
+ break;
+ case T_GrantStmt:
+ retval = _copyGrantStmt(from);
+ break;
+ case T_ClosePortalStmt:
+ retval = _copyClosePortalStmt(from);
+ break;
+ case T_ClusterStmt:
+ retval = _copyClusterStmt(from);
+ break;
+ case T_CopyStmt:
+ retval = _copyCopyStmt(from);
+ break;
+ case T_CreateStmt:
+ retval = _copyCreateStmt(from);
+ break;
+ case T_DefineStmt:
+ retval = _copyDefineStmt(from);
+ break;
+ case T_DropStmt:
+ retval = _copyDropStmt(from);
+ break;
+ case T_TruncateStmt:
+ retval = _copyTruncateStmt(from);
+ break;
+ case T_CommentStmt:
+ retval = _copyCommentStmt(from);
+ break;
+ case T_FetchStmt:
+ retval = _copyFetchStmt(from);
+ break;
+ case T_IndexStmt:
+ retval = _copyIndexStmt(from);
+ break;
+ case T_CreateFunctionStmt:
+ retval = _copyCreateFunctionStmt(from);
+ break;
+ case T_RemoveAggrStmt:
+ retval = _copyRemoveAggrStmt(from);
+ break;
+ case T_RemoveFuncStmt:
+ retval = _copyRemoveFuncStmt(from);
+ break;
+ case T_RemoveOperStmt:
+ retval = _copyRemoveOperStmt(from);
+ break;
+ case T_RenameStmt:
+ retval = _copyRenameStmt(from);
+ break;
+ case T_RuleStmt:
+ retval = _copyRuleStmt(from);
+ break;
+ case T_NotifyStmt:
+ retval = _copyNotifyStmt(from);
+ break;
+ case T_ListenStmt:
+ retval = _copyListenStmt(from);
+ break;
+ case T_UnlistenStmt:
+ retval = _copyUnlistenStmt(from);
+ break;
+ case T_TransactionStmt:
+ retval = _copyTransactionStmt(from);
+ break;
+ case T_ViewStmt:
+ retval = _copyViewStmt(from);
+ break;
+ case T_LoadStmt:
+ retval = _copyLoadStmt(from);
+ break;
+ case T_CreateDomainStmt:
+ retval = _copyCreateDomainStmt(from);
+ break;
+ case T_CreatedbStmt:
+ retval = _copyCreatedbStmt(from);
+ break;
+ case T_AlterDatabaseSetStmt:
+ retval = _copyAlterDatabaseSetStmt(from);
+ break;
+ case T_DropdbStmt:
+ retval = _copyDropdbStmt(from);
+ break;
+ case T_VacuumStmt:
+ retval = _copyVacuumStmt(from);
+ break;
+ case T_ExplainStmt:
+ retval = _copyExplainStmt(from);
+ break;
+ case T_CreateSeqStmt:
+ retval = _copyCreateSeqStmt(from);
+ break;
+ case T_VariableSetStmt:
+ retval = _copyVariableSetStmt(from);
+ break;
+ case T_VariableShowStmt:
+ retval = _copyVariableShowStmt(from);
+ break;
+ case T_VariableResetStmt:
+ retval = _copyVariableResetStmt(from);
+ break;
+ case T_CreateTrigStmt:
+ retval = _copyCreateTrigStmt(from);
+ break;
+ case T_DropPropertyStmt:
+ retval = _copyDropPropertyStmt(from);
+ break;
+ case T_CreatePLangStmt:
+ retval = _copyCreatePLangStmt(from);
+ break;
+ case T_DropPLangStmt:
+ retval = _copyDropPLangStmt(from);
+ break;
+ case T_CreateUserStmt:
+ retval = _copyCreateUserStmt(from);
+ break;
+ case T_AlterUserStmt:
+ retval = _copyAlterUserStmt(from);
+ break;
+ case T_AlterUserSetStmt:
+ retval = _copyAlterUserSetStmt(from);
+ break;
+ case T_DropUserStmt:
+ retval = _copyDropUserStmt(from);
+ break;
+ case T_LockStmt:
+ retval = _copyLockStmt(from);
+ break;
+ case T_ConstraintsSetStmt:
+ retval = _copyConstraintsSetStmt(from);
+ break;
+ case T_CreateGroupStmt:
+ retval = _copyCreateGroupStmt(from);
+ break;
+ case T_AlterGroupStmt:
+ retval = _copyAlterGroupStmt(from);
+ break;
+ case T_DropGroupStmt:
+ retval = _copyDropGroupStmt(from);
+ break;
+ case T_ReindexStmt:
+ retval = _copyReindexStmt(from);
+ break;
+ case T_CheckPointStmt:
+ retval = (void *) makeNode(CheckPointStmt);
+ break;
+ case T_CreateSchemaStmt:
+ retval = _copyCreateSchemaStmt(from);
+ break;
+
+ case T_A_Expr:
+ retval = _copyAExpr(from);
+ break;
+ case T_ColumnRef:
+ retval = _copyColumnRef(from);
+ break;
+ case T_ParamRef:
+ retval = _copyParamRef(from);
+ break;
+ case T_A_Const:
+ retval = _copyAConst(from);
+ break;
+ case T_Ident:
+ retval = _copyIdent(from);
+ break;
+ case T_FuncCall:
+ retval = _copyFuncCall(from);
+ break;
+ case T_A_Indices:
+ retval = _copyAIndices(from);
+ break;
+ case T_ExprFieldSelect:
+ retval = _copyExprFieldSelect(from);
+ break;
+ case T_ResTarget:
+ retval = _copyResTarget(from);
+ break;
+ case T_TypeCast:
+ retval = _copyTypeCast(from);
+ break;
+ 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;
+ case T_RangeFunction:
+ retval = _copyRangeFunction(from);
+ break;
+ case T_TypeName:
+ retval = _copyTypeName(from);
+ break;
+ case T_IndexElem:
+ retval = _copyIndexElem(from);
+ break;
+ case T_ColumnDef:
+ retval = _copyColumnDef(from);
+ break;
+ case T_Constraint:
+ retval = _copyConstraint(from);
+ break;
+ case T_DefElem:
+ retval = _copyDefElem(from);
+ break;
+ case T_TargetEntry:
+ retval = _copyTargetEntry(from);
+ break;
+ case T_RangeTblEntry:
+ retval = _copyRangeTblEntry(from);
+ break;
+ case T_SortClause:
+ retval = _copySortClause(from);
+ break;
+ case T_GroupClause:
+ retval = _copyGroupClause(from);
+ break;
+ case T_CaseExpr:
+ retval = _copyCaseExpr(from);
+ break;
+ case T_CaseWhen:
+ retval = _copyCaseWhen(from);
+ break;
+ case T_NullTest:
+ retval = _copyNullTest(from);
+ break;
+ case T_BooleanTest:
+ retval = _copyBooleanTest(from);
+ break;
+ case T_FkConstraint:
+ retval = _copyFkConstraint(from);
+ break;
+ case T_PrivGrantee:
+ retval = _copyPrivGrantee(from);
+ break;
+ case T_FuncWithArgs:
+ retval = _copyFuncWithArgs(from);
+ break;
+ case T_InsertDefault:
+ retval = _copyInsertDefault(from);
+ break;
+
default:
- elog(ERROR, "copyObject: don't know how to copy %d", nodeTag(from));
- retval = from;
+ elog(ERROR, "copyObject: don't know how to copy node type %d",
+ nodeTag(from));
+ retval = from; /* keep compiler quiet */
break;
}
return retval;