* different executor state node types.
*
*
- * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * 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.149 2001/08/04 19:38:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.192 2002/07/01 15:27:51 tgl Exp $
*
*-------------------------------------------------------------------------
*/
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;
+}
/* ----------------
* CopyJoinFields
return newnode;
}
-static Attr *
-_copyAttr(Attr *from)
-{
- Attr *newnode = makeNode(Attr);
-
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
- Node_Copy(from, newnode, attrs);
-
- return newnode;
-}
-
/* ----------------
* _copyOper
* ----------------
newnode->opno = from->opno;
newnode->opid = from->opid;
newnode->opresulttype = from->opresulttype;
+ newnode->opretset = from->opretset;
/* Do not copy the run-time state, if any */
newnode->op_fcache = NULL;
if (from->constbyval || from->constisnull)
{
-
/*
* passed by value so just copy the datum. Also, don't try to copy
* struct when value is null!
}
else
{
-
/*
* not passed by value. datum contains a pointer.
*/
* copy remainder of node
*/
newnode->funcid = from->funcid;
- newnode->functype = from->functype;
+ newnode->funcresulttype = from->funcresulttype;
+ newnode->funcretset = from->funcretset;
/* Do not copy the run-time state, if any */
newnode->func_fcache = NULL;
{
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->aggstar = from->aggstar;
Node_Copy(from, newnode, using);
Node_Copy(from, newnode, quals);
Node_Copy(from, newnode, alias);
- Node_Copy(from, newnode, colnames);
- Node_Copy(from, newnode, colvars);
+ newnode->rtindex = from->rtindex;
return newnode;
}
static NullTest *
_copyNullTest(NullTest *from)
{
- NullTest *newnode = makeNode(NullTest);
+ NullTest *newnode = makeNode(NullTest);
/*
* copy remainder of node
* _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);
+ newnode->reloptkind = from->reloptkind;
+
newnode->relids = listCopy(from->relids);
newnode->rows = from->rows;
Node_Copy(from, newnode, cheapest_total_path);
newnode->pruneable = from->pruneable;
- newnode->issubquery = from->issubquery;
+ 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);
newnode->indproc = from->indproc;
Node_Copy(from, newnode, indpred);
newnode->unique = from->unique;
- newnode->lossy = from->lossy;
return newnode;
}
static void
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:
*/
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;
}
-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)
{
{
RangeTblEntry *newnode = makeNode(RangeTblEntry);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
+ 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;
if (from->constr_name)
newnode->constr_name = pstrdup(from->constr_name);
- if (from->pktable_name)
- newnode->pktable_name = pstrdup(from->pktable_name);
+ Node_Copy(from, newnode, pktable);
Node_Copy(from, newnode, fk_attrs);
Node_Copy(from, newnode, pk_attrs);
if (from->match_type)
A_Expr *newnode = makeNode(A_Expr);
newnode->oper = from->oper;
- if (from->opname)
- newnode->opname = pstrdup(from->opname);
+ Node_Copy(from, newnode, name);
Node_Copy(from, newnode, lexpr);
Node_Copy(from, newnode, rexpr);
return newnode;
}
-static A_Const *
-_copyAConst(A_Const *from)
+static ColumnRef *
+_copyColumnRef(ColumnRef *from)
{
- A_Const *newnode = makeNode(A_Const);
+ ColumnRef *newnode = makeNode(ColumnRef);
- newnode->val = *((Value *) (copyObject(&(from->val))));
- Node_Copy(from, newnode, typename);
+ Node_Copy(from, newnode, fields);
+ Node_Copy(from, newnode, indirection);
return newnode;
}
-static ParamNo *
-_copyParamNo(ParamNo *from)
+static ParamRef *
+_copyParamRef(ParamRef *from)
{
- ParamNo *newnode = makeNode(ParamNo);
+ ParamRef *newnode = makeNode(ParamRef);
newnode->number = from->number;
- Node_Copy(from, newnode, typename);
+ 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);
- if (from->name)
- newnode->name = pstrdup(from->name);
- Node_Copy(from, newnode, indirection);
- newnode->isRel = from->isRel;
+ newnode->name = pstrdup(from->name);
return newnode;
}
{
FuncCall *newnode = makeNode(FuncCall);
- if (from->funcname)
- newnode->funcname = pstrdup(from->funcname);
+ 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 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)
{
{
TypeName *newnode = makeNode(TypeName);
- if (from->name)
- newnode->name = pstrdup(from->name);
+ 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);
{
SortGroupBy *newnode = makeNode(SortGroupBy);
- if (from->useOp)
- newnode->useOp = pstrdup(from->useOp);
+ 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;
- Node_Copy(from, newnode, name);
+ newnode->istemp = from->istemp;
+ Node_Copy(from, newnode, alias);
return newnode;
}
RangeSubselect *newnode = makeNode(RangeSubselect);
Node_Copy(from, newnode, subquery);
- Node_Copy(from, newnode, name);
+ 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;
}
if (from->name)
newnode->name = pstrdup(from->name);
+ Node_Copy(from, newnode, funcname);
Node_Copy(from, newnode, args);
- if (from->class)
- newnode->class = pstrdup(from->class);
+ Node_Copy(from, newnode, opclass);
return newnode;
}
newnode->colname = pstrdup(from->colname);
Node_Copy(from, newnode, typename);
newnode->is_not_null = from->is_not_null;
- newnode->is_sequence = from->is_sequence;
Node_Copy(from, newnode, raw_default);
if (from->cooked_default)
newnode->cooked_default = pstrdup(from->cooked_default);
newnode->commandType = from->commandType;
Node_Copy(from, newnode, utilityStmt);
newnode->resultRelation = from->resultRelation;
- if (from->into)
- newnode->into = pstrdup(from->into);
+ Node_Copy(from, newnode, into);
newnode->isPortal = from->isPortal;
newnode->isBinary = from->isBinary;
- newnode->isTemp = from->isTemp;
newnode->hasAggs = from->hasAggs;
newnode->hasSubLinks = from->hasSubLinks;
+ newnode->originalQuery = from->originalQuery;
Node_Copy(from, newnode, rtable);
Node_Copy(from, newnode, jointree);
/*
* 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?
+ * other_rel_list, join_rel_list, equi_key_list, query_pathkeys. Not
+ * entirely clear if this is right?
*/
return newnode;
{
InsertStmt *newnode = makeNode(InsertStmt);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
+ Node_Copy(from, newnode, relation);
Node_Copy(from, newnode, cols);
Node_Copy(from, newnode, targetList);
Node_Copy(from, newnode, selectStmt);
{
DeleteStmt *newnode = makeNode(DeleteStmt);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
+ Node_Copy(from, newnode, relation);
Node_Copy(from, newnode, whereClause);
- newnode->inhOpt = from->inhOpt;
return newnode;
}
{
UpdateStmt *newnode = makeNode(UpdateStmt);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
+ Node_Copy(from, newnode, relation);
Node_Copy(from, newnode, targetList);
Node_Copy(from, newnode, whereClause);
Node_Copy(from, newnode, fromClause);
- newnode->inhOpt = from->inhOpt;
return newnode;
}
SelectStmt *newnode = makeNode(SelectStmt);
Node_Copy(from, newnode, distinctClause);
- if (from->into)
- newnode->into = pstrdup(from->into);
- newnode->istemp = from->istemp;
+ 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);
AlterTableStmt *newnode = makeNode(AlterTableStmt);
newnode->subtype = from->subtype;
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
- newnode->inhOpt = from->inhOpt;
+ Node_Copy(from, newnode, relation);
if (from->name)
newnode->name = pstrdup(from->name);
Node_Copy(from, newnode, def);
static GrantStmt *
_copyGrantStmt(GrantStmt *from)
{
- GrantStmt *newnode = makeNode(GrantStmt);
+ GrantStmt *newnode = makeNode(GrantStmt);
newnode->is_grant = from->is_grant;
- Node_Copy(from, newnode, relnames);
- if (from->privileges)
- newnode->privileges = pstrdup(from->privileges);
+ newnode->objtype = from->objtype;
+ Node_Copy(from, newnode, objects);
+ newnode->privileges = listCopy(from->privileges);
Node_Copy(from, newnode, grantees);
return newnode;
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)
{
{
ClusterStmt *newnode = makeNode(ClusterStmt);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
+ Node_Copy(from, newnode, relation);
if (from->indexname)
newnode->indexname = pstrdup(from->indexname);
{
CopyStmt *newnode = makeNode(CopyStmt);
- newnode->binary = from->binary;
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
- newnode->oids = from->oids;
- newnode->direction = from->direction;
+ Node_Copy(from, newnode, relation);
+ newnode->is_from = from->is_from;
if (from->filename)
newnode->filename = pstrdup(from->filename);
- if (from->delimiter)
- newnode->delimiter = pstrdup(from->delimiter);
- if (from->null_print)
- newnode->null_print = pstrdup(from->null_print);
+ Node_Copy(from, newnode, options);
return newnode;
}
{
CreateStmt *newnode = makeNode(CreateStmt);
- newnode->istemp = from->istemp;
- newnode->relname = pstrdup(from->relname);
+ Node_Copy(from, newnode, relation);
Node_Copy(from, newnode, tableElts);
- Node_Copy(from, newnode, inhRelnames);
+ Node_Copy(from, newnode, inhRelations);
Node_Copy(from, newnode, constraints);
-
- return newnode;
-}
-
-static VersionStmt *
-_copyVersionStmt(VersionStmt *from)
-{
- VersionStmt *newnode = makeNode(VersionStmt);
-
- newnode->relname = pstrdup(from->relname);
- newnode->direction = from->direction;
- newnode->fromRelname = pstrdup(from->fromRelname);
- newnode->date = pstrdup(from->date);
+ newnode->hasoids = from->hasoids;
return newnode;
}
DefineStmt *newnode = makeNode(DefineStmt);
newnode->defType = from->defType;
- newnode->defname = pstrdup(from->defname);
+ Node_Copy(from, newnode, defnames);
Node_Copy(from, newnode, definition);
return newnode;
{
DropStmt *newnode = makeNode(DropStmt);
- Node_Copy(from, newnode, names);
+ Node_Copy(from, newnode, objects);
newnode->removeType = from->removeType;
+ newnode->behavior = from->behavior;
return newnode;
}
{
TruncateStmt *newnode = makeNode(TruncateStmt);
- newnode->relName = pstrdup(from->relName);
+ Node_Copy(from, newnode, relation);
return newnode;
}
CommentStmt *newnode = makeNode(CommentStmt);
newnode->objtype = from->objtype;
- newnode->objname = pstrdup(from->objname);
- if (from->objproperty)
- newnode->objproperty = pstrdup(from->objproperty);
- Node_Copy(from, newnode, objlist);
- newnode->comment = pstrdup(from->comment);
+ Node_Copy(from, newnode, objname);
+ Node_Copy(from, newnode, objargs);
+ if (from->comment)
+ newnode->comment = pstrdup(from->comment);
return newnode;
}
IndexStmt *newnode = makeNode(IndexStmt);
newnode->idxname = pstrdup(from->idxname);
- newnode->relname = pstrdup(from->relname);
+ Node_Copy(from, newnode, relation);
newnode->accessMethod = pstrdup(from->accessMethod);
Node_Copy(from, newnode, indexParams);
- Node_Copy(from, newnode, withClause);
Node_Copy(from, newnode, whereClause);
Node_Copy(from, newnode, rangetable);
newnode->unique = from->unique;
return newnode;
}
-static ProcedureStmt *
-_copyProcedureStmt(ProcedureStmt *from)
+static CreateFunctionStmt *
+_copyCreateFunctionStmt(CreateFunctionStmt *from)
{
- ProcedureStmt *newnode = makeNode(ProcedureStmt);
+ CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt);
- newnode->funcname = pstrdup(from->funcname);
+ 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);
- Node_Copy(from, newnode, as);
- newnode->language = pstrdup(from->language);
return newnode;
}
{
RemoveAggrStmt *newnode = makeNode(RemoveAggrStmt);
- newnode->aggname = pstrdup(from->aggname);
+ Node_Copy(from, newnode, aggname);
Node_Copy(from, newnode, aggtype);
+ newnode->behavior = from->behavior;
return newnode;
}
{
RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
- newnode->funcname = pstrdup(from->funcname);
+ Node_Copy(from, newnode, funcname);
Node_Copy(from, newnode, args);
+ newnode->behavior = from->behavior;
return newnode;
}
{
RemoveOperStmt *newnode = makeNode(RemoveOperStmt);
- newnode->opname = pstrdup(from->opname);
+ Node_Copy(from, newnode, opname);
Node_Copy(from, newnode, args);
+ newnode->behavior = from->behavior;
return newnode;
}
{
RenameStmt *newnode = makeNode(RenameStmt);
- newnode->relname = pstrdup(from->relname);
- newnode->inhOpt = from->inhOpt;
- if (from->column)
- newnode->column = pstrdup(from->column);
+ 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;
}
{
RuleStmt *newnode = makeNode(RuleStmt);
+ Node_Copy(from, newnode, relation);
newnode->rulename = pstrdup(from->rulename);
Node_Copy(from, newnode, whereClause);
newnode->event = from->event;
- Node_Copy(from, newnode, object);
newnode->instead = from->instead;
Node_Copy(from, newnode, actions);
{
NotifyStmt *newnode = makeNode(NotifyStmt);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
+ Node_Copy(from, newnode, relation);
return newnode;
}
{
ListenStmt *newnode = makeNode(ListenStmt);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
+ Node_Copy(from, newnode, relation);
return newnode;
}
{
UnlistenStmt *newnode = makeNode(UnlistenStmt);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
+ Node_Copy(from, newnode, relation);
return newnode;
}
{
ViewStmt *newnode = makeNode(ViewStmt);
- if (from->viewname)
- newnode->viewname = pstrdup(from->viewname);
+ Node_Copy(from, newnode, view);
Node_Copy(from, newnode, aliases);
Node_Copy(from, newnode, query);
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)
{
if (from->dbname)
newnode->dbname = pstrdup(from->dbname);
- if (from->dbpath)
- newnode->dbpath = pstrdup(from->dbpath);
- if (from->dbtemplate)
- newnode->dbtemplate = pstrdup(from->dbtemplate);
- newnode->encoding = from->encoding;
+ 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;
}
newnode->vacuum = from->vacuum;
newnode->full = from->full;
newnode->analyze = from->analyze;
+ newnode->freeze = from->freeze;
newnode->verbose = from->verbose;
- if (from->vacrel)
- newnode->vacrel = pstrdup(from->vacrel);
+ Node_Copy(from, newnode, relation);
Node_Copy(from, newnode, va_cols);
return newnode;
Node_Copy(from, newnode, query);
newnode->verbose = from->verbose;
+ newnode->analyze = from->analyze;
return newnode;
}
{
CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
- if (from->seqname)
- newnode->seqname = pstrdup(from->seqname);
+ Node_Copy(from, newnode, sequence);
Node_Copy(from, newnode, options);
return newnode;
if (from->name)
newnode->name = pstrdup(from->name);
- if (from->value)
- newnode->value = pstrdup(from->value);
+ Node_Copy(from, newnode, args);
+ newnode->is_local = from->is_local;
return newnode;
}
if (from->trigname)
newnode->trigname = pstrdup(from->trigname);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
- if (from->funcname)
- newnode->funcname = pstrdup(from->funcname);
+ Node_Copy(from, newnode, relation);
+ Node_Copy(from, newnode, funcname);
Node_Copy(from, newnode, args);
newnode->before = from->before;
newnode->row = from->row;
newnode->isconstraint = from->isconstraint;
newnode->deferrable = from->deferrable;
newnode->initdeferred = from->initdeferred;
- if (from->constrrelname)
- newnode->constrrelname = pstrdup(from->constrrelname);
+ Node_Copy(from, newnode, constrrel);
return newnode;
}
-static DropTrigStmt *
-_copyDropTrigStmt(DropTrigStmt *from)
+static DropPropertyStmt *
+_copyDropPropertyStmt(DropPropertyStmt *from)
{
- DropTrigStmt *newnode = makeNode(DropTrigStmt);
+ DropPropertyStmt *newnode = makeNode(DropPropertyStmt);
- if (from->trigname)
- newnode->trigname = pstrdup(from->trigname);
- if (from->relname)
- newnode->relname = pstrdup(from->relname);
+ Node_Copy(from, newnode, relation);
+ if (from->property)
+ newnode->property = pstrdup(from->property);
+ newnode->removeType = from->removeType;
+ newnode->behavior = from->behavior;
return newnode;
}
if (from->plname)
newnode->plname = pstrdup(from->plname);
- if (from->plhandler)
- newnode->plhandler = pstrdup(from->plhandler);
+ Node_Copy(from, newnode, plhandler);
+ Node_Copy(from, newnode, plvalidator);
if (from->plcompiler)
newnode->plcompiler = pstrdup(from->plcompiler);
newnode->pltrusted = from->pltrusted;
if (from->plname)
newnode->plname = pstrdup(from->plname);
+ newnode->behavior = from->behavior;
return newnode;
}
return newnode;
}
+static AlterUserSetStmt *
+_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);
+
+ return newnode;
+}
+
static DropUserStmt *
_copyDropUserStmt(DropUserStmt *from)
{
{
LockStmt *newnode = makeNode(LockStmt);
- Node_Copy(from, newnode, rellist);
-
+ Node_Copy(from, newnode, relations);
+
newnode->mode = from->mode;
return newnode;
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;
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;
+}
+
/* ****************************************************************
* pg_list.h copy functions
switch (nodeTag(from))
{
-
/*
* PLAN NODES
*/
case T_SubqueryScan:
retval = _copySubqueryScan(from);
break;
+ case T_FunctionScan:
+ retval = _copyFunctionScan(from);
+ break;
case T_Join:
retval = _copyJoin(from);
break;
case T_ArrayRef:
retval = _copyArrayRef(from);
break;
- case T_Iter:
- retval = _copyIter(from);
- break;
case T_FieldSelect:
retval = _copyFieldSelect(from);
break;
case T_CreateStmt:
retval = _copyCreateStmt(from);
break;
- case T_VersionStmt:
- retval = _copyVersionStmt(from);
- break;
case T_DefineStmt:
retval = _copyDefineStmt(from);
break;
case T_IndexStmt:
retval = _copyIndexStmt(from);
break;
- case T_ProcedureStmt:
- retval = _copyProcedureStmt(from);
+ case T_CreateFunctionStmt:
+ retval = _copyCreateFunctionStmt(from);
break;
case T_RemoveAggrStmt:
retval = _copyRemoveAggrStmt(from);
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_CreateTrigStmt:
retval = _copyCreateTrigStmt(from);
break;
- case T_DropTrigStmt:
- retval = _copyDropTrigStmt(from);
+ case T_DropPropertyStmt:
+ retval = _copyDropPropertyStmt(from);
break;
case T_CreatePLangStmt:
retval = _copyCreatePLangStmt(from);
case T_AlterUserStmt:
retval = _copyAlterUserStmt(from);
break;
+ case T_AlterUserSetStmt:
+ retval = _copyAlterUserSetStmt(from);
+ break;
case T_DropUserStmt:
retval = _copyDropUserStmt(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_Attr:
- retval = _copyAttr(from);
+ case T_ColumnRef:
+ retval = _copyColumnRef(from);
+ break;
+ case T_ParamRef:
+ retval = _copyParamRef(from);
break;
case T_A_Const:
retval = _copyAConst(from);
break;
- case T_ParamNo:
- retval = _copyParamNo(from);
- break;
case T_Ident:
retval = _copyIdent(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_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_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 node type %d",