copyObject() and equal() now know about all parse-time node types,

including utility statements.  Still can't copy or compare executor
state, but at present that doesn't seem to be necessary.  This makes
it possible to execute most (all?) utility statements in plpgsql.
Had to change parsetree representation of CreateTrigStmt so that it
contained only legal Nodes, and not bare string constants.

1 files changed, 1004 insertions, 9 deletions

diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 33b630c7934..7270d3116d8 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -10,16 +10,12 @@
  * out, we avoid needing to write copy/compare routines for all the
  * different executor state node types.
  *
- * Another class of nodes not currently handled is nodes that appear
- * only in "raw" parsetrees (gram.y output not yet analyzed by the parser).
- * Perhaps some day that will need to be supported.
- *
  *
  * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *	  $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.119 2000/08/08 15:41:23 tgl Exp $
+ *	  $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.120 2000/08/11 23:45:31 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -28,6 +24,7 @@
 
 #include "optimizer/clauses.h"
 #include "optimizer/planmain.h"
+#include "utils/acl.h"
 
 
 /*
@@ -91,10 +88,10 @@ CopyPlanFields(Plan *from, Plan *newnode)
 	newnode->plan_rows = from->plan_rows;
 	newnode->plan_width = from->plan_width;
 	/* state is NOT copied */
-	newnode->targetlist = copyObject(from->targetlist);
-	newnode->qual = copyObject(from->qual);
-	newnode->lefttree = copyObject(from->lefttree);
-	newnode->righttree = copyObject(from->righttree);
+	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);
@@ -513,6 +510,20 @@ _copyGroupClause(GroupClause *from)
 	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, alias);
+	Node_Copy(from, newnode, quals);
+
+	return newnode;
+}
 
 /* ----------------
  *		_copyUnique
@@ -1381,6 +1392,26 @@ _copyRowMark(RowMark *from)
 	return newnode;
 }
 
+static FkConstraint *
+_copyFkConstraint(FkConstraint *from)
+{
+	FkConstraint    *newnode = makeNode(FkConstraint);
+
+	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, 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)
 {
@@ -1392,6 +1423,20 @@ _copySortClause(SortClause *from)
 	return newnode;
 }
 
+static A_Expr *
+_copyAExpr(A_Expr *from)
+{
+	A_Expr    *newnode = makeNode(A_Expr);
+
+	newnode->oper = from->oper;
+	if (from->opname)
+		newnode->opname = pstrdup(from->opname);
+	Node_Copy(from, newnode, lexpr);
+	Node_Copy(from, newnode, rexpr);
+
+	return newnode;
+}
+
 static A_Const *
 _copyAConst(A_Const *from)
 {
@@ -1403,6 +1448,69 @@ _copyAConst(A_Const *from)
 	return newnode;
 }
 
+static ParamNo *
+_copyParamNo(ParamNo *from)
+{
+	ParamNo    *newnode = makeNode(ParamNo);
+
+	newnode->number = from->number;
+	Node_Copy(from, newnode, typename);
+	Node_Copy(from, newnode, indirection);
+
+	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;
+
+	return newnode;
+}
+
+static FuncCall *
+_copyFuncCall(FuncCall *from)
+{
+	FuncCall    *newnode = makeNode(FuncCall);
+
+	if (from->funcname)
+		newnode->funcname = pstrdup(from->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 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)
 {
@@ -1418,6 +1526,41 @@ _copyTypeName(TypeName *from)
 	return newnode;
 }
 
+static RelExpr *
+_copyRelExpr(RelExpr *from)
+{
+	RelExpr   *newnode = makeNode(RelExpr);
+
+	if (from->relname)
+		newnode->relname = pstrdup(from->relname);
+	newnode->inh = from->inh;
+
+	return newnode;
+}
+
+static SortGroupBy *
+_copySortGroupBy(SortGroupBy *from)
+{
+	SortGroupBy   *newnode = makeNode(SortGroupBy);
+
+	if (from->useOp)
+		newnode->useOp = pstrdup(from->useOp);
+	Node_Copy(from, newnode, node);
+
+	return newnode;
+}
+
+static RangeVar *
+_copyRangeVar(RangeVar *from)
+{
+	RangeVar   *newnode = makeNode(RangeVar);
+
+	Node_Copy(from, newnode, relExpr);
+	Node_Copy(from, newnode, name);
+
+	return newnode;
+}
+
 static TypeCast *
 _copyTypeCast(TypeCast *from)
 {
@@ -1429,6 +1572,66 @@ _copyTypeCast(TypeCast *from)
 	return newnode;
 }
 
+static IndexElem *
+_copyIndexElem(IndexElem *from)
+{
+	IndexElem   *newnode = makeNode(IndexElem);
+
+	if (from->name)
+		newnode->name = pstrdup(from->name);
+	Node_Copy(from, newnode, args);
+	if (from->class)
+		newnode->class = pstrdup(from->class);
+
+	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;
+	newnode->is_sequence = from->is_sequence;
+	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)
 {
@@ -1471,6 +1674,118 @@ _copyQuery(Query *from)
 	return newnode;
 }
 
+static InsertStmt *
+_copyInsertStmt(InsertStmt *from)
+{
+	InsertStmt *newnode = makeNode(InsertStmt);
+	
+	if (from->relname)
+		newnode->relname = pstrdup(from->relname);
+	Node_Copy(from, newnode, distinctClause);
+	Node_Copy(from, newnode, cols);
+	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, unionClause);
+	newnode->unionall = from->unionall;
+	Node_Copy(from, newnode, intersectClause);
+	Node_Copy(from, newnode, forUpdate);
+
+	return newnode;
+}
+
+static DeleteStmt *
+_copyDeleteStmt(DeleteStmt *from)
+{
+	DeleteStmt *newnode = makeNode(DeleteStmt);
+	
+	if (from->relname)
+		newnode->relname = pstrdup(from->relname);
+	Node_Copy(from, newnode, whereClause);
+	newnode->inh = from->inh;
+
+	return newnode;
+}
+
+static UpdateStmt *
+_copyUpdateStmt(UpdateStmt *from)
+{
+	UpdateStmt *newnode = makeNode(UpdateStmt);
+	
+	if (from->relname)
+		newnode->relname = pstrdup(from->relname);
+	Node_Copy(from, newnode, targetList);
+	Node_Copy(from, newnode, whereClause);
+	Node_Copy(from, newnode, fromClause);
+	newnode->inh = from->inh;
+
+	return newnode;
+}
+
+static SelectStmt *
+_copySelectStmt(SelectStmt *from)
+{
+	SelectStmt *newnode = makeNode(SelectStmt);
+	
+	Node_Copy(from, newnode, distinctClause);
+	if (from->into)
+		newnode->into = pstrdup(from->into);
+	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, intersectClause);
+	Node_Copy(from, newnode, exceptClause);
+	Node_Copy(from, newnode, unionClause);
+	Node_Copy(from, newnode, sortClause);
+	if (from->portalname)
+		newnode->portalname = pstrdup(from->portalname);
+	newnode->binary = from->binary;
+	newnode->istemp = from->istemp;
+	newnode->unionall = from->unionall;
+	Node_Copy(from, newnode, limitOffset);
+	Node_Copy(from, newnode, limitCount);
+	Node_Copy(from, newnode, forUpdate);
+
+	return newnode;
+}
+
+static AlterTableStmt *
+_copyAlterTableStmt(AlterTableStmt *from)
+{
+	AlterTableStmt *newnode = makeNode(AlterTableStmt);
+	
+	newnode->subtype = from->subtype;
+	if (from->relname)
+		newnode->relname = pstrdup(from->relname);
+	newnode->inh = from->inh;
+	if (from->name)
+		newnode->name = pstrdup(from->name);
+	Node_Copy(from, newnode, def);
+	newnode->behavior = from->behavior;
+
+	return newnode;
+}
+
+static ChangeACLStmt *
+_copyChangeACLStmt(ChangeACLStmt *from)
+{
+	ChangeACLStmt *newnode = makeNode(ChangeACLStmt);
+	
+	if (from->aclitem)
+	{
+		newnode->aclitem = (struct AclItem *) palloc(sizeof(struct AclItem));
+		memcpy(newnode->aclitem, from->aclitem, sizeof(struct AclItem));
+	}
+	newnode->modechg = from->modechg;
+	Node_Copy(from, newnode, relNames);
+
+	return newnode;
+}
+
 static ClosePortalStmt *
 _copyClosePortalStmt(ClosePortalStmt *from)
 {
@@ -1482,6 +1797,89 @@ _copyClosePortalStmt(ClosePortalStmt *from)
 	return newnode;
 }
 
+static ClusterStmt *
+_copyClusterStmt(ClusterStmt *from)
+{
+	ClusterStmt *newnode = makeNode(ClusterStmt);
+	
+	if (from->relname)
+		newnode->relname = pstrdup(from->relname);
+	if (from->indexname)
+		newnode->indexname = pstrdup(from->indexname);
+
+	return newnode;
+}
+
+static CopyStmt *
+_copyCopyStmt(CopyStmt *from)
+{
+	CopyStmt *newnode = makeNode(CopyStmt);
+	
+	newnode->binary = from->binary;
+	if (from->relname)
+		newnode->relname = pstrdup(from->relname);
+	newnode->oids = from->oids;
+	newnode->direction = from->direction;
+	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);
+
+	return newnode;
+}
+
+static CreateStmt *
+_copyCreateStmt(CreateStmt *from)
+{
+	CreateStmt *newnode = makeNode(CreateStmt);
+	
+	newnode->istemp = from->istemp;
+	newnode->relname = pstrdup(from->relname);
+	Node_Copy(from, newnode, tableElts);
+	Node_Copy(from, newnode, inhRelnames);
+	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);
+
+	return newnode;
+}
+
+static DefineStmt *
+_copyDefineStmt(DefineStmt *from)
+{
+	DefineStmt *newnode = makeNode(DefineStmt);
+	
+	newnode->defType = from->defType;
+	newnode->defname = pstrdup(from->defname);
+	Node_Copy(from, newnode, definition);
+
+	return newnode;
+}
+
+static DropStmt *
+_copyDropStmt(DropStmt *from)
+{
+	DropStmt *newnode = makeNode(DropStmt);
+	
+	Node_Copy(from, newnode, relNames);
+	newnode->sequence = from->sequence;
+
+	return newnode;
+}
+
 static TruncateStmt *
 _copyTruncateStmt(TruncateStmt *from)
 {
@@ -1492,6 +1890,152 @@ _copyTruncateStmt(TruncateStmt *from)
 	return newnode;
 }
 
+static CommentStmt *
+_copyCommentStmt(CommentStmt *from)
+{
+	CommentStmt *newnode = makeNode(CommentStmt);
+	
+	newnode->objtype = from->objtype;
+	newnode->objname = pstrdup(from->objname);
+	newnode->objproperty = pstrdup(from->objproperty);
+	Node_Copy(from, newnode, objlist);
+	newnode->comment = pstrdup(from->comment);
+
+	return newnode;
+}
+
+static ExtendStmt *
+_copyExtendStmt(ExtendStmt *from)
+{
+	ExtendStmt *newnode = makeNode(ExtendStmt);
+	
+	newnode->idxname = pstrdup(from->idxname);
+	Node_Copy(from, newnode, whereClause);
+	Node_Copy(from, newnode, rangetable);
+
+	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);
+	newnode->relname = pstrdup(from->relname);
+	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;
+	newnode->primary = from->primary;
+
+	return newnode;
+}
+
+static ProcedureStmt *
+_copyProcedureStmt(ProcedureStmt *from)
+{
+	ProcedureStmt *newnode = makeNode(ProcedureStmt);
+	
+	newnode->funcname = pstrdup(from->funcname);
+	Node_Copy(from, newnode, defArgs);
+	Node_Copy(from, newnode, returnType);
+	Node_Copy(from, newnode, withClause);
+	Node_Copy(from, newnode, as);
+	newnode->language = pstrdup(from->language);
+
+	return newnode;
+}
+
+static RemoveAggrStmt *
+_copyRemoveAggrStmt(RemoveAggrStmt *from)
+{
+	RemoveAggrStmt *newnode = makeNode(RemoveAggrStmt);
+	
+	newnode->aggname = pstrdup(from->aggname);
+	newnode->aggtype = pstrdup(from->aggtype);
+
+	return newnode;
+}
+
+static RemoveFuncStmt *
+_copyRemoveFuncStmt(RemoveFuncStmt *from)
+{
+	RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
+	
+	newnode->funcname = pstrdup(from->funcname);
+	Node_Copy(from, newnode, args);
+
+	return newnode;
+}
+
+static RemoveOperStmt *
+_copyRemoveOperStmt(RemoveOperStmt *from)
+{
+	RemoveOperStmt *newnode = makeNode(RemoveOperStmt);
+	
+	newnode->opname = pstrdup(from->opname);
+	Node_Copy(from, newnode, args);
+
+	return newnode;
+}
+
+static RemoveStmt *
+_copyRemoveStmt(RemoveStmt *from)
+{
+	RemoveStmt *newnode = makeNode(RemoveStmt);
+	
+	newnode->removeType = from->removeType;
+	newnode->name = pstrdup(from->name);
+
+	return newnode;
+}
+
+static RenameStmt *
+_copyRenameStmt(RenameStmt *from)
+{
+	RenameStmt *newnode = makeNode(RenameStmt);
+	
+	newnode->relname = pstrdup(from->relname);
+	newnode->inh = from->inh;
+	if (from->column)
+		newnode->column = pstrdup(from->column);
+	if (from->newname)
+		newnode->newname = pstrdup(from->newname);
+
+	return newnode;
+}
+
+static RuleStmt *
+_copyRuleStmt(RuleStmt *from)
+{
+	RuleStmt *newnode = makeNode(RuleStmt);
+	
+	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);
+
+	return newnode;
+}
+
 static NotifyStmt *
 _copyNotifyStmt(NotifyStmt *from)
 {
@@ -1535,6 +2079,19 @@ _copyTransactionStmt(TransactionStmt *from)
 	return newnode;
 }
 
+static ViewStmt *
+_copyViewStmt(ViewStmt *from)
+{
+	ViewStmt   *newnode = makeNode(ViewStmt);
+
+	if (from->viewname)
+		newnode->viewname = pstrdup(from->viewname);
+	Node_Copy(from, newnode, aliases);
+	Node_Copy(from, newnode, query);
+
+	return newnode;
+}
+
 static LoadStmt *
 _copyLoadStmt(LoadStmt *from)
 {
@@ -1546,6 +2103,68 @@ _copyLoadStmt(LoadStmt *from)
 	return newnode;
 }
 
+static CreatedbStmt *
+_copyCreatedbStmt(CreatedbStmt *from)
+{
+	CreatedbStmt   *newnode = makeNode(CreatedbStmt);
+
+	if (from->dbname)
+		newnode->dbname = pstrdup(from->dbname);
+	if (from->dbpath)
+		newnode->dbpath = pstrdup(from->dbpath);
+	newnode->encoding = from->encoding;
+
+	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->verbose = from->verbose;
+	newnode->analyze = from->analyze;
+	if (from->vacrel)
+		newnode->vacrel = pstrdup(from->vacrel);
+	Node_Copy(from, newnode, va_spec);
+
+	return newnode;
+}
+
+static ExplainStmt *
+_copyExplainStmt(ExplainStmt *from)
+{
+	ExplainStmt   *newnode = makeNode(ExplainStmt);
+
+	Node_Copy(from, newnode, query);
+	newnode->verbose = from->verbose;
+
+	return newnode;
+}
+
+static CreateSeqStmt *
+_copyCreateSeqStmt(CreateSeqStmt *from)
+{
+	CreateSeqStmt   *newnode = makeNode(CreateSeqStmt);
+
+	if (from->seqname)
+		newnode->seqname = pstrdup(from->seqname);
+	Node_Copy(from, newnode, options);
+
+	return newnode;
+}
+
 static VariableSetStmt *
 _copyVariableSetStmt(VariableSetStmt *from)
 {
@@ -1559,6 +2178,17 @@ _copyVariableSetStmt(VariableSetStmt *from)
 	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)
 {
@@ -1570,6 +2200,123 @@ _copyVariableResetStmt(VariableResetStmt *from)
 	return newnode;
 }
 
+static CreateTrigStmt *
+_copyCreateTrigStmt(CreateTrigStmt *from)
+{
+	CreateTrigStmt *newnode = makeNode(CreateTrigStmt);
+
+	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, 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;
+	if (from->constrrelname)
+		newnode->constrrelname = pstrdup(from->constrrelname);
+
+	return newnode;
+}
+
+static DropTrigStmt *
+_copyDropTrigStmt(DropTrigStmt *from)
+{
+	DropTrigStmt *newnode = makeNode(DropTrigStmt);
+
+	if (from->trigname)
+		newnode->trigname = pstrdup(from->trigname);
+	if (from->relname)
+		newnode->relname = pstrdup(from->relname);
+
+	return newnode;
+}
+
+static CreatePLangStmt *
+_copyCreatePLangStmt(CreatePLangStmt *from)
+{
+	CreatePLangStmt *newnode = makeNode(CreatePLangStmt);
+
+	if (from->plname)
+		newnode->plname = pstrdup(from->plname);
+	if (from->plhandler)
+		newnode->plhandler = pstrdup(from->plhandler);
+	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);
+
+	return newnode;
+}
+
+static CreateUserStmt *
+_copyCreateUserStmt(CreateUserStmt *from)
+{
+	CreateUserStmt *newnode = makeNode(CreateUserStmt);
+
+	if (from->user)
+		newnode->user = pstrdup(from->user);
+	if (from->password)
+		newnode->password = pstrdup(from->password);
+	newnode->sysid = from->sysid;
+	newnode->createdb = from->createdb;
+	newnode->createuser = from->createuser;
+	Node_Copy(from, newnode, groupElts);
+	if (from->validUntil)
+		newnode->validUntil = pstrdup(from->validUntil);
+
+	return newnode;
+}
+
+static AlterUserStmt *
+_copyAlterUserStmt(AlterUserStmt *from)
+{
+	AlterUserStmt *newnode = makeNode(AlterUserStmt);
+
+	if (from->user)
+		newnode->user = pstrdup(from->user);
+	if (from->password)
+		newnode->password = pstrdup(from->password);
+	newnode->createdb = from->createdb;
+	newnode->createuser = from->createuser;
+	if (from->validUntil)
+		newnode->validUntil = pstrdup(from->validUntil);
+
+	return newnode;
+}
+
+static DropUserStmt *
+_copyDropUserStmt(DropUserStmt *from)
+{
+	DropUserStmt *newnode = makeNode(DropUserStmt);
+
+	Node_Copy(from, newnode, users);
+
+	return newnode;
+}
+
 static LockStmt *
 _copyLockStmt(LockStmt *from)
 {
@@ -1582,6 +2329,79 @@ _copyLockStmt(LockStmt *from)
 	return newnode;
 }
 
+static ConstraintsSetStmt *
+_copyConstraintsSetStmt(ConstraintsSetStmt *from)
+{
+	ConstraintsSetStmt   *newnode = makeNode(ConstraintsSetStmt);
+
+	Node_Copy(from, newnode, constraints);
+	newnode->deferred = from->deferred;
+
+	return newnode;
+}
+
+static CreateGroupStmt *
+_copyCreateGroupStmt(CreateGroupStmt *from)
+{
+	CreateGroupStmt   *newnode = makeNode(CreateGroupStmt);
+
+	if (from->name)
+		newnode->name = pstrdup(from->name);
+	newnode->sysid = from->sysid;
+	Node_Copy(from, newnode, initUsers);
+
+	return newnode;
+}
+
+static AlterGroupStmt *
+_copyAlterGroupStmt(AlterGroupStmt *from)
+{
+	AlterGroupStmt   *newnode = makeNode(AlterGroupStmt);
+
+	if (from->name)
+		newnode->name = pstrdup(from->name);
+	newnode->action = from->action;
+	newnode->sysid = from->sysid;
+	Node_Copy(from, newnode, listUsers);
+
+	return newnode;
+}
+
+static DropGroupStmt *
+_copyDropGroupStmt(DropGroupStmt *from)
+{
+	DropGroupStmt   *newnode = makeNode(DropGroupStmt);
+
+	if (from->name)
+		newnode->name = pstrdup(from->name);
+
+	return newnode;
+}
+
+static ReindexStmt *
+_copyReindexStmt(ReindexStmt *from)
+{
+	ReindexStmt   *newnode = makeNode(ReindexStmt);
+
+	newnode->reindexType = from->reindexType;
+	if (from->name)
+		newnode->name = pstrdup(from->name);
+	newnode->force = from->force;
+	newnode->all = from->all;
+
+	return newnode;
+}
+
+static SetSessionStmt *
+_copySetSessionStmt(SetSessionStmt *from)
+{
+	SetSessionStmt   *newnode = makeNode(SetSessionStmt);
+
+	Node_Copy(from, newnode, args);
+
+	return newnode;
+}
+
 
 /* ****************************************************************
  *					pg_list.h copy functions
@@ -1621,6 +2441,7 @@ copyObject(void *from)
 
 	if (from == NULL)
 		return NULL;
+
 	switch (nodeTag(from))
 	{
 
@@ -1801,12 +2622,81 @@ copyObject(void *from)
 		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_AlterTableStmt:
+			retval = _copyAlterTableStmt(from);
+			break;
+		case T_ChangeACLStmt:
+			retval = _copyChangeACLStmt(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_VersionStmt:
+			retval = _copyVersionStmt(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_ExtendStmt:
+			retval = _copyExtendStmt(from);
+			break;
+		case T_FetchStmt:
+			retval = _copyFetchStmt(from);
+			break;
+		case T_IndexStmt:
+			retval = _copyIndexStmt(from);
+			break;
+		case T_ProcedureStmt:
+			retval = _copyProcedureStmt(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_RemoveStmt:
+			retval = _copyRemoveStmt(from);
+			break;
+		case T_RenameStmt:
+			retval = _copyRenameStmt(from);
+			break;
+		case T_RuleStmt:
+			retval = _copyRuleStmt(from);
+			break;
 		case T_NotifyStmt:
 			retval = _copyNotifyStmt(from);
 			break;
@@ -1819,31 +2709,130 @@ copyObject(void *from)
 		case T_TransactionStmt:
 			retval = _copyTransactionStmt(from);
 			break;
+		case T_ViewStmt:
+			retval = _copyViewStmt(from);
+			break;
 		case T_LoadStmt:
 			retval = _copyLoadStmt(from);
 			break;
+		case T_CreatedbStmt:
+			retval = _copyCreatedbStmt(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_DropTrigStmt:
+			retval = _copyDropTrigStmt(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_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_SetSessionStmt:
+			retval = _copySetSessionStmt(from);
+			break;
 
+		case T_A_Expr:
+			retval = _copyAExpr(from);
+			break;
 		case T_Attr:
 			retval = _copyAttr(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_FuncCall:
+			retval = _copyFuncCall(from);
+			break;
+		case T_A_Indices:
+			retval = _copyAIndices(from);
+			break;
+		case T_ResTarget:
+			retval = _copyResTarget(from);
+			break;
 		case T_TypeCast:
 			retval = _copyTypeCast(from);
 			break;
+		case T_RelExpr:
+			retval = _copyRelExpr(from);
+			break;
+		case T_SortGroupBy:
+			retval = _copySortGroupBy(from);
+			break;
+		case T_RangeVar:
+			retval = _copyRangeVar(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;
@@ -1856,6 +2845,9 @@ copyObject(void *from)
 		case T_GroupClause:
 			retval = _copyGroupClause(from);
 			break;
+		case T_JoinExpr:
+			retval = _copyJoinExpr(from);
+			break;
 		case T_CaseExpr:
 			retval = _copyCaseExpr(from);
 			break;
@@ -1865,6 +2857,9 @@ copyObject(void *from)
 		case T_RowMark:
 			retval = _copyRowMark(from);
 			break;
+		case T_FkConstraint:
+			retval = _copyFkConstraint(from);
+			break;
 
 		default:
 			elog(ERROR, "copyObject: don't know how to copy node type %d",