* be handled easily in a simple depth-first traversal.
*
*
- * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2007, 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.266 2003/11/09 21:30:36 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.362 2007/01/20 20:45:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
-#include "nodes/parsenodes.h"
#include "nodes/plannodes.h"
#include "nodes/relation.h"
#include "utils/datum.h"
#define COPY_NODE_FIELD(fldname) \
(newnode->fldname = copyObject(from->fldname))
-/* Copy a field that is a pointer to a list of integers */
-#define COPY_INTLIST_FIELD(fldname) \
- (newnode->fldname = listCopy(from->fldname))
-
-/* Copy a field that is a pointer to a list of Oids */
-#define COPY_OIDLIST_FIELD(fldname) \
- (newnode->fldname = listCopy(from->fldname))
-
/* Copy a field that is a pointer to a Bitmapset */
#define COPY_BITMAPSET_FIELD(fldname) \
(newnode->fldname = bms_copy(from->fldname))
} while (0)
-/*
- * listCopy
- * This copy function only copies the "cons-cells" of the list, not the
- * pointed-to objects. (Use copyObject if you want a "deep" copy.)
- *
- * We also use this function for copying lists of integers and Oids,
- * which is notationally a bit ugly, but perfectly safe.
- *
- * Note that copyObject will surely coredump if applied to a list
- * of integers or Oids!
- */
-List *
-listCopy(List *list)
-{
- List *newlist,
- *oldl,
- *newcell,
- *prev;
-
- /* rather ugly coding for speed... */
- if (list == NIL)
- return NIL;
-
- newcell = makeNode(List);
- newcell->elem = list->elem;
-
- newlist = prev = newcell;
-
- foreach(oldl, lnext(list))
- {
- newcell = makeNode(List);
- newcell->elem = oldl->elem;
- prev->next = newcell;
- prev = newcell;
- }
- prev->next = NIL;
-
- return newlist;
-}
-
/* ****************************************************************
* plannodes.h copy functions
* ****************************************************************
return newnode;
}
+/*
+ * _copyBitmapAnd
+ */
+static BitmapAnd *
+_copyBitmapAnd(BitmapAnd *from)
+{
+ BitmapAnd *newnode = makeNode(BitmapAnd);
+
+ /*
+ * copy node superclass fields
+ */
+ CopyPlanFields((Plan *) from, (Plan *) newnode);
+
+ /*
+ * copy remainder of node
+ */
+ COPY_NODE_FIELD(bitmapplans);
+
+ return newnode;
+}
+
+/*
+ * _copyBitmapOr
+ */
+static BitmapOr *
+_copyBitmapOr(BitmapOr *from)
+{
+ BitmapOr *newnode = makeNode(BitmapOr);
+
+ /*
+ * copy node superclass fields
+ */
+ CopyPlanFields((Plan *) from, (Plan *) newnode);
+
+ /*
+ * copy remainder of node
+ */
+ COPY_NODE_FIELD(bitmapplans);
+
+ return newnode;
+}
+
/*
* CopyScanFields
/*
* copy remainder of node
*/
- COPY_OIDLIST_FIELD(indxid);
- COPY_NODE_FIELD(indxqual);
- COPY_NODE_FIELD(indxqualorig);
- /* this can become COPY_NODE_FIELD when intlists are normal objects: */
- {
- List *newstrat = NIL;
- List *tmp;
-
- foreach(tmp, from->indxstrategy)
- {
- newstrat = lappend(newstrat, listCopy(lfirst(tmp)));
- }
- newnode->indxstrategy = newstrat;
- }
- COPY_SCALAR_FIELD(indxorderdir);
+ COPY_SCALAR_FIELD(indexid);
+ COPY_NODE_FIELD(indexqual);
+ COPY_NODE_FIELD(indexqualorig);
+ COPY_NODE_FIELD(indexstrategy);
+ COPY_NODE_FIELD(indexsubtype);
+ COPY_SCALAR_FIELD(indexorderdir);
+
+ return newnode;
+}
+
+/*
+ * _copyBitmapIndexScan
+ */
+static BitmapIndexScan *
+_copyBitmapIndexScan(BitmapIndexScan *from)
+{
+ BitmapIndexScan *newnode = makeNode(BitmapIndexScan);
+
+ /*
+ * copy node superclass fields
+ */
+ CopyScanFields((Scan *) from, (Scan *) newnode);
+
+ /*
+ * copy remainder of node
+ */
+ COPY_SCALAR_FIELD(indexid);
+ COPY_NODE_FIELD(indexqual);
+ COPY_NODE_FIELD(indexqualorig);
+ COPY_NODE_FIELD(indexstrategy);
+ COPY_NODE_FIELD(indexsubtype);
+
+ return newnode;
+}
+
+/*
+ * _copyBitmapHeapScan
+ */
+static BitmapHeapScan *
+_copyBitmapHeapScan(BitmapHeapScan *from)
+{
+ BitmapHeapScan *newnode = makeNode(BitmapHeapScan);
+
+ /*
+ * copy node superclass fields
+ */
+ CopyScanFields((Scan *) from, (Scan *) newnode);
+
+ /*
+ * copy remainder of node
+ */
+ COPY_NODE_FIELD(bitmapqualorig);
return newnode;
}
/*
* copy remainder of node
*/
- COPY_NODE_FIELD(tideval);
+ COPY_NODE_FIELD(tidquals);
return newnode;
}
return newnode;
}
+/*
+ * _copyValuesScan
+ */
+static ValuesScan *
+_copyValuesScan(ValuesScan *from)
+{
+ ValuesScan *newnode = makeNode(ValuesScan);
+
+ /*
+ * copy node superclass fields
+ */
+ CopyScanFields((Scan *) from, (Scan *) newnode);
+
+ return newnode;
+}
+
/*
* CopyJoinFields
*
_copyMergeJoin(MergeJoin *from)
{
MergeJoin *newnode = makeNode(MergeJoin);
+ int numCols;
/*
* copy node superclass fields
* copy remainder of node
*/
COPY_NODE_FIELD(mergeclauses);
+ numCols = list_length(from->mergeclauses);
+ COPY_POINTER_FIELD(mergeFamilies, numCols * sizeof(Oid));
+ COPY_POINTER_FIELD(mergeStrategies, numCols * sizeof(int));
+ COPY_POINTER_FIELD(mergeNullsFirst, numCols * sizeof(bool));
return newnode;
}
COPY_SCALAR_FIELD(numCols);
COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
+ COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
return newnode;
}
COPY_SCALAR_FIELD(numCols);
COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
+ COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
return newnode;
}
COPY_SCALAR_FIELD(aggstrategy);
COPY_SCALAR_FIELD(numCols);
if (from->numCols > 0)
+ {
COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
+ COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
+ }
COPY_SCALAR_FIELD(numGroups);
return newnode;
*/
COPY_SCALAR_FIELD(numCols);
COPY_POINTER_FIELD(uniqColIdx, from->numCols * sizeof(AttrNumber));
+ COPY_POINTER_FIELD(uniqOperators, from->numCols * sizeof(Oid));
return newnode;
}
/*
* copy remainder of node
*/
- COPY_NODE_FIELD(hashkeys);
return newnode;
}
COPY_SCALAR_FIELD(cmd);
COPY_SCALAR_FIELD(numCols);
COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
+ COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
COPY_SCALAR_FIELD(flagColIdx);
return newnode;
* ****************************************************************
*/
-/*
- * _copyResdom
- */
-static Resdom *
-_copyResdom(Resdom *from)
-{
- Resdom *newnode = makeNode(Resdom);
-
- COPY_SCALAR_FIELD(resno);
- COPY_SCALAR_FIELD(restype);
- COPY_SCALAR_FIELD(restypmod);
- COPY_STRING_FIELD(resname);
- COPY_SCALAR_FIELD(ressortgroupref);
- COPY_SCALAR_FIELD(resorigtbl);
- COPY_SCALAR_FIELD(resorigcol);
- COPY_SCALAR_FIELD(resjunk);
-
- return newnode;
-}
-
/*
* _copyAlias
*/
COPY_SCALAR_FIELD(paramkind);
COPY_SCALAR_FIELD(paramid);
- COPY_STRING_FIELD(paramname);
COPY_SCALAR_FIELD(paramtype);
+ COPY_SCALAR_FIELD(paramtypmod);
return newnode;
}
COPY_SCALAR_FIELD(aggfnoid);
COPY_SCALAR_FIELD(aggtype);
- COPY_NODE_FIELD(target);
+ COPY_NODE_FIELD(args);
COPY_SCALAR_FIELD(agglevelsup);
COPY_SCALAR_FIELD(aggstar);
COPY_SCALAR_FIELD(aggdistinct);
SubLink *newnode = makeNode(SubLink);
COPY_SCALAR_FIELD(subLinkType);
- COPY_SCALAR_FIELD(useOr);
- COPY_NODE_FIELD(lefthand);
+ COPY_NODE_FIELD(testexpr);
COPY_NODE_FIELD(operName);
- COPY_OIDLIST_FIELD(operOids);
COPY_NODE_FIELD(subselect);
return newnode;
SubPlan *newnode = makeNode(SubPlan);
COPY_SCALAR_FIELD(subLinkType);
- COPY_SCALAR_FIELD(useOr);
- COPY_NODE_FIELD(exprs);
- COPY_INTLIST_FIELD(paramIds);
+ COPY_NODE_FIELD(testexpr);
+ COPY_NODE_FIELD(paramIds);
COPY_NODE_FIELD(plan);
COPY_SCALAR_FIELD(plan_id);
COPY_NODE_FIELD(rtable);
COPY_SCALAR_FIELD(useHashTable);
COPY_SCALAR_FIELD(unknownEqFalse);
- COPY_INTLIST_FIELD(setParam);
- COPY_INTLIST_FIELD(parParam);
+ COPY_NODE_FIELD(setParam);
+ COPY_NODE_FIELD(parParam);
COPY_NODE_FIELD(args);
return newnode;
return newnode;
}
+/*
+ * _copyFieldStore
+ */
+static FieldStore *
+_copyFieldStore(FieldStore *from)
+{
+ FieldStore *newnode = makeNode(FieldStore);
+
+ COPY_NODE_FIELD(arg);
+ COPY_NODE_FIELD(newvals);
+ COPY_NODE_FIELD(fieldnums);
+ COPY_SCALAR_FIELD(resulttype);
+
+ return newnode;
+}
+
/*
* _copyRelabelType
*/
return newnode;
}
+/*
+ * _copyConvertRowtypeExpr
+ */
+static ConvertRowtypeExpr *
+_copyConvertRowtypeExpr(ConvertRowtypeExpr *from)
+{
+ ConvertRowtypeExpr *newnode = makeNode(ConvertRowtypeExpr);
+
+ COPY_NODE_FIELD(arg);
+ COPY_SCALAR_FIELD(resulttype);
+ COPY_SCALAR_FIELD(convertformat);
+
+ return newnode;
+}
+
/*
* _copyCaseExpr
*/
return newnode;
}
+/*
+ * _copyCaseTestExpr
+ */
+static CaseTestExpr *
+_copyCaseTestExpr(CaseTestExpr *from)
+{
+ CaseTestExpr *newnode = makeNode(CaseTestExpr);
+
+ COPY_SCALAR_FIELD(typeId);
+ COPY_SCALAR_FIELD(typeMod);
+
+ return newnode;
+}
+
/*
* _copyArrayExpr
*/
return newnode;
}
+/*
+ * _copyRowExpr
+ */
+static RowExpr *
+_copyRowExpr(RowExpr *from)
+{
+ RowExpr *newnode = makeNode(RowExpr);
+
+ COPY_NODE_FIELD(args);
+ COPY_SCALAR_FIELD(row_typeid);
+ COPY_SCALAR_FIELD(row_format);
+
+ return newnode;
+}
+
+/*
+ * _copyRowCompareExpr
+ */
+static RowCompareExpr *
+_copyRowCompareExpr(RowCompareExpr *from)
+{
+ RowCompareExpr *newnode = makeNode(RowCompareExpr);
+
+ COPY_SCALAR_FIELD(rctype);
+ COPY_NODE_FIELD(opnos);
+ COPY_NODE_FIELD(opfamilies);
+ COPY_NODE_FIELD(largs);
+ COPY_NODE_FIELD(rargs);
+
+ return newnode;
+}
+
/*
* _copyCoalesceExpr
*/
return newnode;
}
+/*
+ * _copyMinMaxExpr
+ */
+static MinMaxExpr *
+_copyMinMaxExpr(MinMaxExpr *from)
+{
+ MinMaxExpr *newnode = makeNode(MinMaxExpr);
+
+ COPY_SCALAR_FIELD(minmaxtype);
+ COPY_SCALAR_FIELD(op);
+ COPY_NODE_FIELD(args);
+
+ return newnode;
+}
+
+/*
+ * _copyXmlExpr
+ */
+static XmlExpr *
+_copyXmlExpr(XmlExpr *from)
+{
+ XmlExpr *newnode = makeNode(XmlExpr);
+
+ COPY_SCALAR_FIELD(op);
+ COPY_STRING_FIELD(name);
+ COPY_NODE_FIELD(named_args);
+ COPY_NODE_FIELD(arg_names);
+ COPY_NODE_FIELD(args);
+
+ return newnode;
+}
+
/*
* _copyNullIfExpr (same as OpExpr)
*/
{
TargetEntry *newnode = makeNode(TargetEntry);
- COPY_NODE_FIELD(resdom);
COPY_NODE_FIELD(expr);
+ COPY_SCALAR_FIELD(resno);
+ COPY_STRING_FIELD(resname);
+ COPY_SCALAR_FIELD(ressortgroupref);
+ COPY_SCALAR_FIELD(resorigtbl);
+ COPY_SCALAR_FIELD(resorigcol);
+ COPY_SCALAR_FIELD(resjunk);
return newnode;
}
*/
/*
- * _copyPathKeyItem
+ * _copyPathKey
*/
-static PathKeyItem *
-_copyPathKeyItem(PathKeyItem *from)
+static PathKey *
+_copyPathKey(PathKey *from)
{
- PathKeyItem *newnode = makeNode(PathKeyItem);
+ PathKey *newnode = makeNode(PathKey);
- COPY_NODE_FIELD(key);
- COPY_SCALAR_FIELD(sortop);
+ /* EquivalenceClasses are never moved, so just shallow-copy the pointer */
+ COPY_SCALAR_FIELD(pk_eclass);
+ COPY_SCALAR_FIELD(pk_opfamily);
+ COPY_SCALAR_FIELD(pk_strategy);
+ COPY_SCALAR_FIELD(pk_nulls_first);
return newnode;
}
RestrictInfo *newnode = makeNode(RestrictInfo);
COPY_NODE_FIELD(clause);
- COPY_SCALAR_FIELD(ispusheddown);
- COPY_NODE_FIELD(subclauseindices); /* XXX probably bad */
- COPY_SCALAR_FIELD(eval_cost);
- COPY_SCALAR_FIELD(this_selec);
+ COPY_SCALAR_FIELD(is_pushed_down);
+ COPY_SCALAR_FIELD(outerjoin_delayed);
+ COPY_SCALAR_FIELD(can_join);
+ COPY_SCALAR_FIELD(pseudoconstant);
+ COPY_BITMAPSET_FIELD(clause_relids);
+ COPY_BITMAPSET_FIELD(required_relids);
COPY_BITMAPSET_FIELD(left_relids);
COPY_BITMAPSET_FIELD(right_relids);
- COPY_SCALAR_FIELD(mergejoinoperator);
- COPY_SCALAR_FIELD(left_sortop);
- COPY_SCALAR_FIELD(right_sortop);
-
- /*
- * Do not copy pathkeys, since they'd not be canonical in a copied
- * query
- */
- newnode->left_pathkey = NIL;
- newnode->right_pathkey = NIL;
-
- COPY_SCALAR_FIELD(left_mergescansel);
- COPY_SCALAR_FIELD(right_mergescansel);
+ COPY_NODE_FIELD(orclause);
+ /* EquivalenceClasses are never copied, so shallow-copy the pointers */
+ COPY_SCALAR_FIELD(parent_ec);
+ COPY_SCALAR_FIELD(eval_cost);
+ COPY_SCALAR_FIELD(this_selec);
+ COPY_NODE_FIELD(mergeopfamilies);
+ /* EquivalenceClasses are never copied, so shallow-copy the pointers */
+ COPY_SCALAR_FIELD(left_ec);
+ COPY_SCALAR_FIELD(right_ec);
+ COPY_SCALAR_FIELD(outer_is_left);
COPY_SCALAR_FIELD(hashjoinoperator);
COPY_SCALAR_FIELD(left_bucketsize);
COPY_SCALAR_FIELD(right_bucketsize);
}
/*
- * _copyJoinInfo
+ * _copyOuterJoinInfo
*/
-static JoinInfo *
-_copyJoinInfo(JoinInfo *from)
+static OuterJoinInfo *
+_copyOuterJoinInfo(OuterJoinInfo *from)
{
- JoinInfo *newnode = makeNode(JoinInfo);
+ OuterJoinInfo *newnode = makeNode(OuterJoinInfo);
- COPY_BITMAPSET_FIELD(unjoined_relids);
- COPY_NODE_FIELD(jinfo_restrictinfo);
+ COPY_BITMAPSET_FIELD(min_lefthand);
+ COPY_BITMAPSET_FIELD(min_righthand);
+ COPY_SCALAR_FIELD(is_full_join);
+ COPY_SCALAR_FIELD(lhs_strict);
return newnode;
}
COPY_BITMAPSET_FIELD(lefthand);
COPY_BITMAPSET_FIELD(righthand);
COPY_NODE_FIELD(sub_targetlist);
+ COPY_NODE_FIELD(in_operators);
+
+ return newnode;
+}
+
+/*
+ * _copyAppendRelInfo
+ */
+static AppendRelInfo *
+_copyAppendRelInfo(AppendRelInfo *from)
+{
+ AppendRelInfo *newnode = makeNode(AppendRelInfo);
+
+ COPY_SCALAR_FIELD(parent_relid);
+ COPY_SCALAR_FIELD(child_relid);
+ COPY_SCALAR_FIELD(parent_reltype);
+ COPY_SCALAR_FIELD(child_reltype);
+ COPY_NODE_FIELD(col_mappings);
+ COPY_NODE_FIELD(translated_vars);
+ COPY_SCALAR_FIELD(parent_reloid);
return newnode;
}
COPY_SCALAR_FIELD(relid);
COPY_NODE_FIELD(subquery);
COPY_NODE_FIELD(funcexpr);
- COPY_NODE_FIELD(coldeflist);
+ COPY_NODE_FIELD(funccoltypes);
+ COPY_NODE_FIELD(funccoltypmods);
+ COPY_NODE_FIELD(values_lists);
COPY_SCALAR_FIELD(jointype);
COPY_NODE_FIELD(joinaliasvars);
COPY_NODE_FIELD(alias);
COPY_NODE_FIELD(eref);
COPY_SCALAR_FIELD(inh);
COPY_SCALAR_FIELD(inFromCl);
- COPY_SCALAR_FIELD(checkForRead);
- COPY_SCALAR_FIELD(checkForWrite);
+ COPY_SCALAR_FIELD(requiredPerms);
COPY_SCALAR_FIELD(checkAsUser);
return newnode;
COPY_SCALAR_FIELD(tleSortGroupRef);
COPY_SCALAR_FIELD(sortop);
+ COPY_SCALAR_FIELD(nulls_first);
return newnode;
}
COPY_SCALAR_FIELD(tleSortGroupRef);
COPY_SCALAR_FIELD(sortop);
+ COPY_SCALAR_FIELD(nulls_first);
+
+ return newnode;
+}
+
+static RowMarkClause *
+_copyRowMarkClause(RowMarkClause *from)
+{
+ RowMarkClause *newnode = makeNode(RowMarkClause);
+
+ COPY_SCALAR_FIELD(rti);
+ COPY_SCALAR_FIELD(forUpdate);
+ COPY_SCALAR_FIELD(noWait);
return newnode;
}
COPY_NODE_FIELD(name);
COPY_NODE_FIELD(lexpr);
COPY_NODE_FIELD(rexpr);
+ COPY_SCALAR_FIELD(location);
return newnode;
}
ColumnRef *newnode = makeNode(ColumnRef);
COPY_NODE_FIELD(fields);
- COPY_NODE_FIELD(indirection);
+ COPY_SCALAR_FIELD(location);
return newnode;
}
ParamRef *newnode = makeNode(ParamRef);
COPY_SCALAR_FIELD(number);
- COPY_NODE_FIELD(fields);
- COPY_NODE_FIELD(indirection);
return newnode;
}
COPY_NODE_FIELD(args);
COPY_SCALAR_FIELD(agg_star);
COPY_SCALAR_FIELD(agg_distinct);
+ COPY_SCALAR_FIELD(location);
return newnode;
}
return newnode;
}
-static ExprFieldSelect *
-_copyExprFieldSelect(ExprFieldSelect *from)
+static A_Indirection *
+_copyA_Indirection(A_Indirection *from)
{
- ExprFieldSelect *newnode = makeNode(ExprFieldSelect);
+ A_Indirection *newnode = makeNode(A_Indirection);
COPY_NODE_FIELD(arg);
- COPY_NODE_FIELD(fields);
COPY_NODE_FIELD(indirection);
return newnode;
COPY_STRING_FIELD(name);
COPY_NODE_FIELD(indirection);
COPY_NODE_FIELD(val);
+ COPY_SCALAR_FIELD(location);
return newnode;
}
COPY_SCALAR_FIELD(timezone);
COPY_SCALAR_FIELD(setof);
COPY_SCALAR_FIELD(pct_type);
- COPY_SCALAR_FIELD(typmod);
+ COPY_NODE_FIELD(typmods);
+ COPY_SCALAR_FIELD(typemod);
COPY_NODE_FIELD(arrayBounds);
+ COPY_SCALAR_FIELD(location);
return newnode;
}
static SortBy *
_copySortBy(SortBy *from)
{
- SortBy *newnode = makeNode(SortBy);
+ SortBy *newnode = makeNode(SortBy);
- COPY_SCALAR_FIELD(sortby_kind);
+ COPY_SCALAR_FIELD(sortby_dir);
+ COPY_SCALAR_FIELD(sortby_nulls);
COPY_NODE_FIELD(useOp);
COPY_NODE_FIELD(node);
COPY_STRING_FIELD(name);
COPY_NODE_FIELD(expr);
COPY_NODE_FIELD(opclass);
+ COPY_SCALAR_FIELD(ordering);
+ COPY_SCALAR_FIELD(nulls_ordering);
return newnode;
}
COPY_NODE_FIELD(raw_default);
COPY_STRING_FIELD(cooked_default);
COPY_NODE_FIELD(constraints);
- COPY_NODE_FIELD(support);
return newnode;
}
COPY_NODE_FIELD(raw_expr);
COPY_STRING_FIELD(cooked_expr);
COPY_NODE_FIELD(keys);
+ COPY_NODE_FIELD(options);
+ COPY_STRING_FIELD(indexspace);
return newnode;
}
return newnode;
}
+static LockingClause *
+_copyLockingClause(LockingClause *from)
+{
+ LockingClause *newnode = makeNode(LockingClause);
+
+ COPY_NODE_FIELD(lockedRels);
+ COPY_SCALAR_FIELD(forUpdate);
+ COPY_SCALAR_FIELD(noWait);
+
+ return newnode;
+}
+
static Query *
_copyQuery(Query *from)
{
COPY_NODE_FIELD(utilityStmt);
COPY_SCALAR_FIELD(resultRelation);
COPY_NODE_FIELD(into);
+ COPY_NODE_FIELD(intoOptions);
+ COPY_SCALAR_FIELD(intoOnCommit);
+ COPY_STRING_FIELD(intoTableSpaceName);
COPY_SCALAR_FIELD(hasAggs);
COPY_SCALAR_FIELD(hasSubLinks);
COPY_NODE_FIELD(rtable);
COPY_NODE_FIELD(jointree);
- COPY_INTLIST_FIELD(rowMarks);
COPY_NODE_FIELD(targetList);
+ COPY_NODE_FIELD(returningList);
COPY_NODE_FIELD(groupClause);
COPY_NODE_FIELD(havingQual);
COPY_NODE_FIELD(distinctClause);
COPY_NODE_FIELD(sortClause);
COPY_NODE_FIELD(limitOffset);
COPY_NODE_FIELD(limitCount);
+ COPY_NODE_FIELD(rowMarks);
COPY_NODE_FIELD(setOperations);
- COPY_INTLIST_FIELD(resultRelations);
- COPY_NODE_FIELD(in_info_list);
- COPY_SCALAR_FIELD(hasJoinRTEs);
-
- /*
- * We do not copy the other planner internal fields: base_rel_list,
- * other_rel_list, join_rel_list, equi_key_list, query_pathkeys. That
- * would get us into copying RelOptInfo/Path trees, which we don't
- * want to do. It is necessary to copy in_info_list and hasJoinRTEs
- * for the benefit of inheritance_planner(), which may try to copy a
- * Query in which these are already set.
- */
+ COPY_NODE_FIELD(resultRelations);
+ COPY_NODE_FIELD(returningLists);
return newnode;
}
COPY_NODE_FIELD(relation);
COPY_NODE_FIELD(cols);
- COPY_NODE_FIELD(targetList);
COPY_NODE_FIELD(selectStmt);
+ COPY_NODE_FIELD(returningList);
return newnode;
}
DeleteStmt *newnode = makeNode(DeleteStmt);
COPY_NODE_FIELD(relation);
+ COPY_NODE_FIELD(usingClause);
COPY_NODE_FIELD(whereClause);
+ COPY_NODE_FIELD(returningList);
return newnode;
}
COPY_NODE_FIELD(targetList);
COPY_NODE_FIELD(whereClause);
COPY_NODE_FIELD(fromClause);
+ COPY_NODE_FIELD(returningList);
return newnode;
}
COPY_NODE_FIELD(distinctClause);
COPY_NODE_FIELD(into);
COPY_NODE_FIELD(intoColNames);
+ COPY_NODE_FIELD(intoOptions);
+ COPY_SCALAR_FIELD(intoOnCommit);
+ COPY_STRING_FIELD(intoTableSpaceName);
COPY_NODE_FIELD(targetList);
COPY_NODE_FIELD(fromClause);
COPY_NODE_FIELD(whereClause);
COPY_NODE_FIELD(groupClause);
COPY_NODE_FIELD(havingClause);
+ COPY_NODE_FIELD(valuesLists);
COPY_NODE_FIELD(sortClause);
COPY_NODE_FIELD(limitOffset);
COPY_NODE_FIELD(limitCount);
- COPY_NODE_FIELD(forUpdate);
+ COPY_NODE_FIELD(lockingClause);
COPY_SCALAR_FIELD(op);
COPY_SCALAR_FIELD(all);
COPY_NODE_FIELD(larg);
COPY_SCALAR_FIELD(all);
COPY_NODE_FIELD(larg);
COPY_NODE_FIELD(rarg);
- COPY_OIDLIST_FIELD(colTypes);
+ COPY_NODE_FIELD(colTypes);
+ COPY_NODE_FIELD(colTypmods);
return newnode;
}
{
AlterTableStmt *newnode = makeNode(AlterTableStmt);
- COPY_SCALAR_FIELD(subtype);
COPY_NODE_FIELD(relation);
+ COPY_NODE_FIELD(cmds);
+ COPY_SCALAR_FIELD(relkind);
+
+ return newnode;
+}
+
+static AlterTableCmd *
+_copyAlterTableCmd(AlterTableCmd *from)
+{
+ AlterTableCmd *newnode = makeNode(AlterTableCmd);
+
+ COPY_SCALAR_FIELD(subtype);
COPY_STRING_FIELD(name);
COPY_NODE_FIELD(def);
+ COPY_NODE_FIELD(transform);
COPY_SCALAR_FIELD(behavior);
return newnode;
COPY_SCALAR_FIELD(is_grant);
COPY_SCALAR_FIELD(objtype);
COPY_NODE_FIELD(objects);
- COPY_INTLIST_FIELD(privileges);
+ COPY_NODE_FIELD(privileges);
COPY_NODE_FIELD(grantees);
COPY_SCALAR_FIELD(grant_option);
COPY_SCALAR_FIELD(behavior);
{
PrivGrantee *newnode = makeNode(PrivGrantee);
- COPY_STRING_FIELD(username);
- COPY_STRING_FIELD(groupname);
+ COPY_STRING_FIELD(rolname);
return newnode;
}
return newnode;
}
+static GrantRoleStmt *
+_copyGrantRoleStmt(GrantRoleStmt *from)
+{
+ GrantRoleStmt *newnode = makeNode(GrantRoleStmt);
+
+ COPY_NODE_FIELD(granted_roles);
+ COPY_NODE_FIELD(grantee_roles);
+ COPY_SCALAR_FIELD(is_grant);
+ COPY_SCALAR_FIELD(admin_opt);
+ COPY_STRING_FIELD(grantor);
+ COPY_SCALAR_FIELD(behavior);
+
+ return newnode;
+}
+
static DeclareCursorStmt *
_copyDeclareCursorStmt(DeclareCursorStmt *from)
{
CopyStmt *newnode = makeNode(CopyStmt);
COPY_NODE_FIELD(relation);
+ COPY_NODE_FIELD(query);
COPY_NODE_FIELD(attlist);
COPY_SCALAR_FIELD(is_from);
COPY_STRING_FIELD(filename);
COPY_NODE_FIELD(tableElts);
COPY_NODE_FIELD(inhRelations);
COPY_NODE_FIELD(constraints);
- COPY_SCALAR_FIELD(hasoids);
+ COPY_NODE_FIELD(options);
COPY_SCALAR_FIELD(oncommit);
+ COPY_STRING_FIELD(tablespacename);
return newnode;
}
InhRelation *newnode = makeNode(InhRelation);
COPY_NODE_FIELD(relation);
- COPY_SCALAR_FIELD(including_defaults);
+ COPY_NODE_FIELD(options);
return newnode;
}
DefineStmt *newnode = makeNode(DefineStmt);
COPY_SCALAR_FIELD(kind);
+ COPY_SCALAR_FIELD(oldstyle);
COPY_NODE_FIELD(defnames);
+ COPY_NODE_FIELD(args);
COPY_NODE_FIELD(definition);
return newnode;
COPY_NODE_FIELD(objects);
COPY_SCALAR_FIELD(removeType);
COPY_SCALAR_FIELD(behavior);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
{
TruncateStmt *newnode = makeNode(TruncateStmt);
- COPY_NODE_FIELD(relation);
+ COPY_NODE_FIELD(relations);
+ COPY_SCALAR_FIELD(behavior);
return newnode;
}
COPY_STRING_FIELD(idxname);
COPY_NODE_FIELD(relation);
COPY_STRING_FIELD(accessMethod);
+ COPY_STRING_FIELD(tableSpace);
COPY_NODE_FIELD(indexParams);
+ COPY_NODE_FIELD(options);
COPY_NODE_FIELD(whereClause);
COPY_NODE_FIELD(rangetable);
COPY_SCALAR_FIELD(unique);
COPY_SCALAR_FIELD(primary);
COPY_SCALAR_FIELD(isconstraint);
+ COPY_SCALAR_FIELD(concurrent);
return newnode;
}
COPY_SCALAR_FIELD(replace);
COPY_NODE_FIELD(funcname);
- COPY_NODE_FIELD(argTypes);
+ COPY_NODE_FIELD(parameters);
COPY_NODE_FIELD(returnType);
COPY_NODE_FIELD(options);
COPY_NODE_FIELD(withClause);
return newnode;
}
-static RemoveAggrStmt *
-_copyRemoveAggrStmt(RemoveAggrStmt *from)
+static FunctionParameter *
+_copyFunctionParameter(FunctionParameter *from)
{
- RemoveAggrStmt *newnode = makeNode(RemoveAggrStmt);
+ FunctionParameter *newnode = makeNode(FunctionParameter);
- COPY_NODE_FIELD(aggname);
- COPY_NODE_FIELD(aggtype);
- COPY_SCALAR_FIELD(behavior);
+ COPY_STRING_FIELD(name);
+ COPY_NODE_FIELD(argType);
+ COPY_SCALAR_FIELD(mode);
return newnode;
}
-static RemoveFuncStmt *
-_copyRemoveFuncStmt(RemoveFuncStmt *from)
+static AlterFunctionStmt *
+_copyAlterFunctionStmt(AlterFunctionStmt *from)
{
- RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
+ AlterFunctionStmt *newnode = makeNode(AlterFunctionStmt);
- COPY_NODE_FIELD(funcname);
- COPY_NODE_FIELD(args);
- COPY_SCALAR_FIELD(behavior);
+ COPY_NODE_FIELD(func);
+ COPY_NODE_FIELD(actions);
return newnode;
}
-static RemoveOperStmt *
-_copyRemoveOperStmt(RemoveOperStmt *from)
+static RemoveFuncStmt *
+_copyRemoveFuncStmt(RemoveFuncStmt *from)
{
- RemoveOperStmt *newnode = makeNode(RemoveOperStmt);
+ RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
- COPY_NODE_FIELD(opname);
+ COPY_SCALAR_FIELD(kind);
+ COPY_NODE_FIELD(name);
COPY_NODE_FIELD(args);
COPY_SCALAR_FIELD(behavior);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
COPY_NODE_FIELD(opclassname);
COPY_STRING_FIELD(amname);
COPY_SCALAR_FIELD(behavior);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
{
RenameStmt *newnode = makeNode(RenameStmt);
+ COPY_SCALAR_FIELD(renameType);
COPY_NODE_FIELD(relation);
COPY_NODE_FIELD(object);
COPY_NODE_FIELD(objarg);
COPY_STRING_FIELD(subname);
COPY_STRING_FIELD(newname);
- COPY_SCALAR_FIELD(renameType);
+
+ return newnode;
+}
+
+static AlterObjectSchemaStmt *
+_copyAlterObjectSchemaStmt(AlterObjectSchemaStmt *from)
+{
+ AlterObjectSchemaStmt *newnode = makeNode(AlterObjectSchemaStmt);
+
+ COPY_SCALAR_FIELD(objectType);
+ COPY_NODE_FIELD(relation);
+ COPY_NODE_FIELD(object);
+ COPY_NODE_FIELD(objarg);
+ COPY_STRING_FIELD(addname);
+ COPY_STRING_FIELD(newschema);
+
+ return newnode;
+}
+
+static AlterOwnerStmt *
+_copyAlterOwnerStmt(AlterOwnerStmt *from)
+{
+ AlterOwnerStmt *newnode = makeNode(AlterOwnerStmt);
+
+ COPY_SCALAR_FIELD(objectType);
+ COPY_NODE_FIELD(relation);
+ COPY_NODE_FIELD(object);
+ COPY_NODE_FIELD(objarg);
+ COPY_STRING_FIELD(addname);
+ COPY_STRING_FIELD(newowner);
return newnode;
}
COPY_SCALAR_FIELD(kind);
COPY_NODE_FIELD(options);
+ COPY_STRING_FIELD(gid);
return newnode;
}
CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt);
COPY_NODE_FIELD(opclassname);
+ COPY_NODE_FIELD(opfamilyname);
COPY_STRING_FIELD(amname);
COPY_NODE_FIELD(datatype);
COPY_NODE_FIELD(items);
return newnode;
}
+static AlterDatabaseStmt *
+_copyAlterDatabaseStmt(AlterDatabaseStmt *from)
+{
+ AlterDatabaseStmt *newnode = makeNode(AlterDatabaseStmt);
+
+ COPY_STRING_FIELD(dbname);
+ COPY_NODE_FIELD(options);
+
+ return newnode;
+}
+
static AlterDatabaseSetStmt *
_copyAlterDatabaseSetStmt(AlterDatabaseSetStmt *from)
{
DropdbStmt *newnode = makeNode(DropdbStmt);
COPY_STRING_FIELD(dbname);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
COPY_SCALAR_FIELD(vacuum);
COPY_SCALAR_FIELD(full);
COPY_SCALAR_FIELD(analyze);
- COPY_SCALAR_FIELD(freeze);
COPY_SCALAR_FIELD(verbose);
+ COPY_SCALAR_FIELD(freeze_min_age);
COPY_NODE_FIELD(relation);
COPY_NODE_FIELD(va_cols);
return newnode;
}
+static CreateTableSpaceStmt *
+_copyCreateTableSpaceStmt(CreateTableSpaceStmt *from)
+{
+ CreateTableSpaceStmt *newnode = makeNode(CreateTableSpaceStmt);
+
+ COPY_STRING_FIELD(tablespacename);
+ COPY_STRING_FIELD(owner);
+ COPY_STRING_FIELD(location);
+
+ return newnode;
+}
+
+static DropTableSpaceStmt *
+_copyDropTableSpaceStmt(DropTableSpaceStmt *from)
+{
+ DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt);
+
+ COPY_STRING_FIELD(tablespacename);
+ COPY_SCALAR_FIELD(missing_ok);
+
+ return newnode;
+}
+
static CreateTrigStmt *
_copyCreateTrigStmt(CreateTrigStmt *from)
{
COPY_STRING_FIELD(property);
COPY_SCALAR_FIELD(removeType);
COPY_SCALAR_FIELD(behavior);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
COPY_STRING_FIELD(plname);
COPY_SCALAR_FIELD(behavior);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
-static CreateUserStmt *
-_copyCreateUserStmt(CreateUserStmt *from)
+static CreateRoleStmt *
+_copyCreateRoleStmt(CreateRoleStmt *from)
{
- CreateUserStmt *newnode = makeNode(CreateUserStmt);
+ CreateRoleStmt *newnode = makeNode(CreateRoleStmt);
- COPY_STRING_FIELD(user);
+ COPY_SCALAR_FIELD(stmt_type);
+ COPY_STRING_FIELD(role);
COPY_NODE_FIELD(options);
return newnode;
}
-static AlterUserStmt *
-_copyAlterUserStmt(AlterUserStmt *from)
+static AlterRoleStmt *
+_copyAlterRoleStmt(AlterRoleStmt *from)
{
- AlterUserStmt *newnode = makeNode(AlterUserStmt);
+ AlterRoleStmt *newnode = makeNode(AlterRoleStmt);
- COPY_STRING_FIELD(user);
+ COPY_STRING_FIELD(role);
COPY_NODE_FIELD(options);
+ COPY_SCALAR_FIELD(action);
return newnode;
}
-static AlterUserSetStmt *
-_copyAlterUserSetStmt(AlterUserSetStmt *from)
+static AlterRoleSetStmt *
+_copyAlterRoleSetStmt(AlterRoleSetStmt *from)
{
- AlterUserSetStmt *newnode = makeNode(AlterUserSetStmt);
+ AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt);
- COPY_STRING_FIELD(user);
+ COPY_STRING_FIELD(role);
COPY_STRING_FIELD(variable);
COPY_NODE_FIELD(value);
return newnode;
}
-static DropUserStmt *
-_copyDropUserStmt(DropUserStmt *from)
+static DropRoleStmt *
+_copyDropRoleStmt(DropRoleStmt *from)
{
- DropUserStmt *newnode = makeNode(DropUserStmt);
+ DropRoleStmt *newnode = makeNode(DropRoleStmt);
- COPY_NODE_FIELD(users);
+ COPY_NODE_FIELD(roles);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
COPY_NODE_FIELD(relations);
COPY_SCALAR_FIELD(mode);
+ COPY_SCALAR_FIELD(nowait);
return newnode;
}
return newnode;
}
-static CreateGroupStmt *
-_copyCreateGroupStmt(CreateGroupStmt *from)
-{
- CreateGroupStmt *newnode = makeNode(CreateGroupStmt);
-
- COPY_STRING_FIELD(name);
- COPY_NODE_FIELD(options);
-
- return newnode;
-}
-
-static AlterGroupStmt *
-_copyAlterGroupStmt(AlterGroupStmt *from)
-{
- AlterGroupStmt *newnode = makeNode(AlterGroupStmt);
-
- COPY_STRING_FIELD(name);
- COPY_SCALAR_FIELD(action);
- COPY_NODE_FIELD(listUsers);
-
- return newnode;
-}
-
-static DropGroupStmt *
-_copyDropGroupStmt(DropGroupStmt *from)
-{
- DropGroupStmt *newnode = makeNode(DropGroupStmt);
-
- COPY_STRING_FIELD(name);
-
- return newnode;
-}
-
static ReindexStmt *
_copyReindexStmt(ReindexStmt *from)
{
COPY_SCALAR_FIELD(kind);
COPY_NODE_FIELD(relation);
COPY_STRING_FIELD(name);
- COPY_SCALAR_FIELD(force);
- COPY_SCALAR_FIELD(all);
+ COPY_SCALAR_FIELD(do_system);
+ COPY_SCALAR_FIELD(do_user);
return newnode;
}
COPY_NODE_FIELD(sourcetype);
COPY_NODE_FIELD(targettype);
COPY_SCALAR_FIELD(behavior);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
COPY_STRING_FIELD(name);
COPY_NODE_FIELD(argtypes);
- COPY_OIDLIST_FIELD(argtype_oids);
+ COPY_NODE_FIELD(argtype_oids);
COPY_NODE_FIELD(query);
return newnode;
COPY_STRING_FIELD(name);
COPY_NODE_FIELD(into);
+ COPY_NODE_FIELD(intoOptions);
+ COPY_SCALAR_FIELD(into_on_commit);
+ COPY_STRING_FIELD(into_tbl_space);
COPY_NODE_FIELD(params);
return newnode;
return newnode;
}
+static DropOwnedStmt *
+_copyDropOwnedStmt(DropOwnedStmt *from)
+{
+ DropOwnedStmt *newnode = makeNode(DropOwnedStmt);
+
+ COPY_NODE_FIELD(roles);
+ COPY_SCALAR_FIELD(behavior);
+
+ return newnode;
+}
+
+static ReassignOwnedStmt *
+_copyReassignOwnedStmt(ReassignOwnedStmt *from)
+{
+ ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt);
+
+ COPY_NODE_FIELD(roles);
+ COPY_SCALAR_FIELD(newrole);
+
+ return newnode;
+}
/* ****************************************************************
* pg_list.h copy functions
* ****************************************************************
*/
+/*
+ * Perform a deep copy of the specified list, using copyObject(). The
+ * list MUST be of type T_List; T_IntList and T_OidList nodes don't
+ * need deep copies, so they should be copied via list_copy()
+ */
+#define COPY_NODE_CELL(new, old) \
+ (new) = (ListCell *) palloc(sizeof(ListCell)); \
+ lfirst(new) = copyObject(lfirst(old));
+
+static List *
+_copyList(List *from)
+{
+ List *new;
+ ListCell *curr_old;
+ ListCell *prev_new;
+
+ Assert(list_length(from) >= 1);
+
+ new = makeNode(List);
+ new->length = from->length;
+
+ COPY_NODE_CELL(new->head, from->head);
+ prev_new = new->head;
+ curr_old = lnext(from->head);
+
+ while (curr_old)
+ {
+ COPY_NODE_CELL(prev_new->next, curr_old);
+ prev_new = prev_new->next;
+ curr_old = curr_old->next;
+ }
+ prev_new->next = NULL;
+ new->tail = prev_new;
+
+ return new;
+}
+
+/* ****************************************************************
+ * value.h copy functions
+ * ****************************************************************
+ */
static Value *
_copyValue(Value *from)
{
case T_Append:
retval = _copyAppend(from);
break;
+ case T_BitmapAnd:
+ retval = _copyBitmapAnd(from);
+ break;
+ case T_BitmapOr:
+ retval = _copyBitmapOr(from);
+ break;
case T_Scan:
retval = _copyScan(from);
break;
case T_IndexScan:
retval = _copyIndexScan(from);
break;
+ case T_BitmapIndexScan:
+ retval = _copyBitmapIndexScan(from);
+ break;
+ case T_BitmapHeapScan:
+ retval = _copyBitmapHeapScan(from);
+ break;
case T_TidScan:
retval = _copyTidScan(from);
break;
case T_FunctionScan:
retval = _copyFunctionScan(from);
break;
+ case T_ValuesScan:
+ retval = _copyValuesScan(from);
+ break;
case T_Join:
retval = _copyJoin(from);
break;
/*
* PRIMITIVE NODES
*/
- case T_Resdom:
- retval = _copyResdom(from);
- break;
case T_Alias:
retval = _copyAlias(from);
break;
case T_FieldSelect:
retval = _copyFieldSelect(from);
break;
+ case T_FieldStore:
+ retval = _copyFieldStore(from);
+ break;
case T_RelabelType:
retval = _copyRelabelType(from);
break;
+ case T_ConvertRowtypeExpr:
+ retval = _copyConvertRowtypeExpr(from);
+ break;
case T_CaseExpr:
retval = _copyCaseExpr(from);
break;
case T_CaseWhen:
retval = _copyCaseWhen(from);
break;
+ case T_CaseTestExpr:
+ retval = _copyCaseTestExpr(from);
+ break;
case T_ArrayExpr:
retval = _copyArrayExpr(from);
break;
+ case T_RowExpr:
+ retval = _copyRowExpr(from);
+ break;
+ case T_RowCompareExpr:
+ retval = _copyRowCompareExpr(from);
+ break;
case T_CoalesceExpr:
retval = _copyCoalesceExpr(from);
break;
+ case T_MinMaxExpr:
+ retval = _copyMinMaxExpr(from);
+ break;
+ case T_XmlExpr:
+ retval = _copyXmlExpr(from);
+ break;
case T_NullIfExpr:
retval = _copyNullIfExpr(from);
break;
/*
* RELATION NODES
*/
- case T_PathKeyItem:
- retval = _copyPathKeyItem(from);
+ case T_PathKey:
+ retval = _copyPathKey(from);
break;
case T_RestrictInfo:
retval = _copyRestrictInfo(from);
break;
- case T_JoinInfo:
- retval = _copyJoinInfo(from);
+ case T_OuterJoinInfo:
+ retval = _copyOuterJoinInfo(from);
break;
case T_InClauseInfo:
retval = _copyInClauseInfo(from);
break;
+ case T_AppendRelInfo:
+ retval = _copyAppendRelInfo(from);
+ break;
/*
* VALUE NODES
case T_Null:
retval = _copyValue(from);
break;
+
+ /*
+ * LIST NODES
+ */
case T_List:
- {
- List *list = from,
- *oldl,
- *newcell,
- *prev;
-
- /* rather ugly coding for speed... */
- /* Note the input list cannot be NIL if we got here. */
- newcell = makeNode(List);
- lfirst(newcell) = copyObject(lfirst(list));
-
- retval = (void *) newcell;
- prev = newcell;
-
- foreach(oldl, lnext(list))
- {
- newcell = makeNode(List);
- lfirst(newcell) = copyObject(lfirst(oldl));
- prev->next = newcell;
- prev = newcell;
- }
- prev->next = NIL;
- }
+ retval = _copyList(from);
+ break;
+
+ /*
+ * Lists of integers and OIDs don't need to be deep-copied, so we
+ * perform a shallow copy via list_copy()
+ */
+ case T_IntList:
+ case T_OidList:
+ retval = list_copy(from);
break;
/*
case T_AlterTableStmt:
retval = _copyAlterTableStmt(from);
break;
+ case T_AlterTableCmd:
+ retval = _copyAlterTableCmd(from);
+ break;
case T_AlterDomainStmt:
retval = _copyAlterDomainStmt(from);
break;
case T_GrantStmt:
retval = _copyGrantStmt(from);
break;
+ case T_GrantRoleStmt:
+ retval = _copyGrantRoleStmt(from);
+ break;
case T_DeclareCursorStmt:
retval = _copyDeclareCursorStmt(from);
break;
case T_CreateFunctionStmt:
retval = _copyCreateFunctionStmt(from);
break;
- case T_RemoveAggrStmt:
- retval = _copyRemoveAggrStmt(from);
+ case T_FunctionParameter:
+ retval = _copyFunctionParameter(from);
+ break;
+ case T_AlterFunctionStmt:
+ retval = _copyAlterFunctionStmt(from);
break;
case T_RemoveFuncStmt:
retval = _copyRemoveFuncStmt(from);
break;
- case T_RemoveOperStmt:
- retval = _copyRemoveOperStmt(from);
- break;
case T_RemoveOpClassStmt:
retval = _copyRemoveOpClassStmt(from);
break;
case T_RenameStmt:
retval = _copyRenameStmt(from);
break;
+ case T_AlterObjectSchemaStmt:
+ retval = _copyAlterObjectSchemaStmt(from);
+ break;
+ case T_AlterOwnerStmt:
+ retval = _copyAlterOwnerStmt(from);
+ break;
case T_RuleStmt:
retval = _copyRuleStmt(from);
break;
case T_CreatedbStmt:
retval = _copyCreatedbStmt(from);
break;
+ case T_AlterDatabaseStmt:
+ retval = _copyAlterDatabaseStmt(from);
+ break;
case T_AlterDatabaseSetStmt:
retval = _copyAlterDatabaseSetStmt(from);
break;
case T_VariableResetStmt:
retval = _copyVariableResetStmt(from);
break;
+ case T_CreateTableSpaceStmt:
+ retval = _copyCreateTableSpaceStmt(from);
+ break;
+ case T_DropTableSpaceStmt:
+ retval = _copyDropTableSpaceStmt(from);
+ break;
case T_CreateTrigStmt:
retval = _copyCreateTrigStmt(from);
break;
case T_DropPLangStmt:
retval = _copyDropPLangStmt(from);
break;
- case T_CreateUserStmt:
- retval = _copyCreateUserStmt(from);
+ case T_CreateRoleStmt:
+ retval = _copyCreateRoleStmt(from);
break;
- case T_AlterUserStmt:
- retval = _copyAlterUserStmt(from);
+ case T_AlterRoleStmt:
+ retval = _copyAlterRoleStmt(from);
break;
- case T_AlterUserSetStmt:
- retval = _copyAlterUserSetStmt(from);
+ case T_AlterRoleSetStmt:
+ retval = _copyAlterRoleSetStmt(from);
break;
- case T_DropUserStmt:
- retval = _copyDropUserStmt(from);
+ case T_DropRoleStmt:
+ retval = _copyDropRoleStmt(from);
break;
case T_LockStmt:
retval = _copyLockStmt(from);
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_DeallocateStmt:
retval = _copyDeallocateStmt(from);
break;
+ case T_DropOwnedStmt:
+ retval = _copyDropOwnedStmt(from);
+ break;
+ case T_ReassignOwnedStmt:
+ retval = _copyReassignOwnedStmt(from);
+ break;
case T_A_Expr:
retval = _copyAExpr(from);
case T_A_Indices:
retval = _copyAIndices(from);
break;
- case T_ExprFieldSelect:
- retval = _copyExprFieldSelect(from);
+ case T_A_Indirection:
+ retval = _copyA_Indirection(from);
break;
case T_ResTarget:
retval = _copyResTarget(from);
case T_DefElem:
retval = _copyDefElem(from);
break;
+ case T_LockingClause:
+ retval = _copyLockingClause(from);
+ break;
case T_RangeTblEntry:
retval = _copyRangeTblEntry(from);
break;
case T_GroupClause:
retval = _copyGroupClause(from);
break;
+ case T_RowMarkClause:
+ retval = _copyRowMarkClause(from);
+ break;
case T_FkConstraint:
retval = _copyFkConstraint(from);
break;
projects / postgresql / blobdiff