* be handled easily in a simple depth-first traversal.
*
*
- * Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.329 2006/03/05 15:58:27 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.383 2007/10/11 18:05:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
-#include "nodes/parsenodes.h"
#include "nodes/plannodes.h"
#include "nodes/relation.h"
#include "utils/datum.h"
* ****************************************************************
*/
+/*
+ * _copyPlannedStmt
+ */
+static PlannedStmt *
+_copyPlannedStmt(PlannedStmt *from)
+{
+ PlannedStmt *newnode = makeNode(PlannedStmt);
+
+ COPY_SCALAR_FIELD(commandType);
+ COPY_SCALAR_FIELD(canSetTag);
+ COPY_NODE_FIELD(planTree);
+ COPY_NODE_FIELD(rtable);
+ COPY_NODE_FIELD(resultRelations);
+ COPY_NODE_FIELD(utilityStmt);
+ COPY_NODE_FIELD(intoClause);
+ COPY_NODE_FIELD(subplans);
+ COPY_BITMAPSET_FIELD(rewindPlanIDs);
+ COPY_NODE_FIELD(returningLists);
+ COPY_NODE_FIELD(rowMarks);
+ COPY_NODE_FIELD(relationOids);
+ COPY_SCALAR_FIELD(nParamExec);
+
+ return newnode;
+}
+
/*
* CopyPlanFields
*
COPY_NODE_FIELD(initPlan);
COPY_BITMAPSET_FIELD(extParam);
COPY_BITMAPSET_FIELD(allParam);
- COPY_SCALAR_FIELD(nParamExec);
}
/*
* copy remainder of node
*/
COPY_NODE_FIELD(subplan);
+ COPY_NODE_FIELD(subrtable);
return newnode;
}
*/
CopyScanFields((Scan *) from, (Scan *) newnode);
+ /*
+ * copy remainder of node
+ */
+ COPY_NODE_FIELD(funcexpr);
+ COPY_NODE_FIELD(funccolnames);
+ COPY_NODE_FIELD(funccoltypes);
+ COPY_NODE_FIELD(funccoltypmods);
+
+ return newnode;
+}
+
+/*
+ * _copyValuesScan
+ */
+static ValuesScan *
+_copyValuesScan(ValuesScan *from)
+{
+ ValuesScan *newnode = makeNode(ValuesScan);
+
+ /*
+ * copy node superclass fields
+ */
+ CopyScanFields((Scan *) from, (Scan *) newnode);
+
+ /*
+ * copy remainder of node
+ */
+ COPY_NODE_FIELD(values_lists);
+
return newnode;
}
_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_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;
return newnode;
}
+/*
+ * _copyIntoClause
+ */
+static IntoClause *
+_copyIntoClause(IntoClause *from)
+{
+ IntoClause *newnode = makeNode(IntoClause);
+
+ COPY_NODE_FIELD(rel);
+ COPY_NODE_FIELD(colNames);
+ COPY_NODE_FIELD(options);
+ COPY_SCALAR_FIELD(onCommit);
+ COPY_STRING_FIELD(tableSpaceName);
+
+ return newnode;
+}
+
/*
* We don't need a _copyExpr because Expr is an abstract supertype which
* should never actually get instantiated. Also, since it has no common
Const *newnode = makeNode(Const);
COPY_SCALAR_FIELD(consttype);
+ COPY_SCALAR_FIELD(consttypmod);
COPY_SCALAR_FIELD(constlen);
if (from->constbyval || from->constisnull)
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);
{
ArrayRef *newnode = makeNode(ArrayRef);
- COPY_SCALAR_FIELD(refrestype);
COPY_SCALAR_FIELD(refarraytype);
COPY_SCALAR_FIELD(refelemtype);
+ COPY_SCALAR_FIELD(reftypmod);
COPY_NODE_FIELD(refupperindexpr);
COPY_NODE_FIELD(reflowerindexpr);
COPY_NODE_FIELD(refexpr);
COPY_SCALAR_FIELD(subLinkType);
COPY_NODE_FIELD(testexpr);
COPY_NODE_FIELD(paramIds);
- COPY_NODE_FIELD(plan);
COPY_SCALAR_FIELD(plan_id);
- COPY_NODE_FIELD(rtable);
+ COPY_SCALAR_FIELD(firstColType);
COPY_SCALAR_FIELD(useHashTable);
COPY_SCALAR_FIELD(unknownEqFalse);
COPY_NODE_FIELD(setParam);
return newnode;
}
+/*
+ * _copyCoerceViaIO
+ */
+static CoerceViaIO *
+_copyCoerceViaIO(CoerceViaIO *from)
+{
+ CoerceViaIO *newnode = makeNode(CoerceViaIO);
+
+ COPY_NODE_FIELD(arg);
+ COPY_SCALAR_FIELD(resulttype);
+ COPY_SCALAR_FIELD(coerceformat);
+
+ return newnode;
+}
+
+/*
+ * _copyArrayCoerceExpr
+ */
+static ArrayCoerceExpr *
+_copyArrayCoerceExpr(ArrayCoerceExpr *from)
+{
+ ArrayCoerceExpr *newnode = makeNode(ArrayCoerceExpr);
+
+ COPY_NODE_FIELD(arg);
+ COPY_SCALAR_FIELD(elemfuncid);
+ COPY_SCALAR_FIELD(resulttype);
+ COPY_SCALAR_FIELD(resulttypmod);
+ COPY_SCALAR_FIELD(isExplicit);
+ COPY_SCALAR_FIELD(coerceformat);
+
+ return newnode;
+}
+
/*
* _copyConvertRowtypeExpr
*/
static RowCompareExpr *
_copyRowCompareExpr(RowCompareExpr *from)
{
- RowCompareExpr *newnode = makeNode(RowCompareExpr);
+ RowCompareExpr *newnode = makeNode(RowCompareExpr);
COPY_SCALAR_FIELD(rctype);
COPY_NODE_FIELD(opnos);
- COPY_NODE_FIELD(opclasses);
+ COPY_NODE_FIELD(opfamilies);
COPY_NODE_FIELD(largs);
COPY_NODE_FIELD(rargs);
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);
+ COPY_SCALAR_FIELD(xmloption);
+ COPY_SCALAR_FIELD(type);
+ COPY_SCALAR_FIELD(typmod);
+
+ return newnode;
+}
+
/*
* _copyNullIfExpr (same as OpExpr)
*/
return newnode;
}
+/*
+ * _copyCurrentOfExpr
+ */
+static CurrentOfExpr *
+_copyCurrentOfExpr(CurrentOfExpr *from)
+{
+ CurrentOfExpr *newnode = makeNode(CurrentOfExpr);
+
+ COPY_SCALAR_FIELD(cvarno);
+ COPY_STRING_FIELD(cursor_name);
+ COPY_SCALAR_FIELD(cursor_param);
+
+ return newnode;
+}
+
/*
* _copyTargetEntry
*/
*/
/*
- * _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;
}
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_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_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(mergeopfamilies);
+ /* EquivalenceClasses are never copied, so shallow-copy the pointers */
+ COPY_SCALAR_FIELD(left_ec);
+ COPY_SCALAR_FIELD(right_ec);
+ COPY_SCALAR_FIELD(left_em);
+ COPY_SCALAR_FIELD(right_em);
+ /* MergeScanSelCache isn't a Node, so hard to copy; just reset cache */
+ newnode->scansel_cache = NIL;
+ COPY_SCALAR_FIELD(outer_is_left);
COPY_SCALAR_FIELD(hashjoinoperator);
COPY_SCALAR_FIELD(left_bucketsize);
COPY_SCALAR_FIELD(right_bucketsize);
COPY_BITMAPSET_FIELD(min_lefthand);
COPY_BITMAPSET_FIELD(min_righthand);
+ COPY_BITMAPSET_FIELD(syn_lefthand);
+ COPY_BITMAPSET_FIELD(syn_righthand);
COPY_SCALAR_FIELD(is_full_join);
COPY_SCALAR_FIELD(lhs_strict);
+ COPY_SCALAR_FIELD(delay_upper_joins);
return newnode;
}
COPY_BITMAPSET_FIELD(lefthand);
COPY_BITMAPSET_FIELD(righthand);
COPY_NODE_FIELD(sub_targetlist);
+ COPY_NODE_FIELD(in_operators);
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_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_SCALAR_FIELD(location);
return newnode;
}
COPY_NODE_FIELD(args);
COPY_SCALAR_FIELD(agg_star);
COPY_SCALAR_FIELD(agg_distinct);
+ COPY_SCALAR_FIELD(location);
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;
}
{
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;
COPY_NODE_FIELD(lockedRels);
COPY_SCALAR_FIELD(forUpdate);
- COPY_SCALAR_FIELD(nowait);
+ COPY_SCALAR_FIELD(noWait);
+
+ return newnode;
+}
+
+static XmlSerialize *
+_copyXmlSerialize(XmlSerialize *from)
+{
+ XmlSerialize *newnode = makeNode(XmlSerialize);
+
+ COPY_SCALAR_FIELD(xmloption);
+ COPY_NODE_FIELD(expr);
+ COPY_NODE_FIELD(typename);
return newnode;
}
COPY_SCALAR_FIELD(canSetTag);
COPY_NODE_FIELD(utilityStmt);
COPY_SCALAR_FIELD(resultRelation);
- COPY_NODE_FIELD(into);
- COPY_SCALAR_FIELD(intoHasOids);
- COPY_SCALAR_FIELD(intoOnCommit);
- COPY_STRING_FIELD(intoTableSpaceName);
+ COPY_NODE_FIELD(intoClause);
COPY_SCALAR_FIELD(hasAggs);
COPY_SCALAR_FIELD(hasSubLinks);
COPY_NODE_FIELD(rtable);
COPY_NODE_FIELD(jointree);
- COPY_NODE_FIELD(rowMarks);
- COPY_SCALAR_FIELD(forUpdate);
- COPY_SCALAR_FIELD(rowNoWait);
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_NODE_FIELD(resultRelations);
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(whereClause);
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;
}
SelectStmt *newnode = makeNode(SelectStmt);
COPY_NODE_FIELD(distinctClause);
- COPY_NODE_FIELD(into);
- COPY_NODE_FIELD(intoColNames);
- COPY_SCALAR_FIELD(intoHasOids);
- COPY_SCALAR_FIELD(intoOnCommit);
- COPY_STRING_FIELD(intoTableSpaceName);
+ COPY_NODE_FIELD(intoClause);
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(larg);
COPY_NODE_FIELD(rarg);
COPY_NODE_FIELD(colTypes);
+ COPY_NODE_FIELD(colTypmods);
return newnode;
}
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);
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_STRING_FIELD(accessMethod);
COPY_STRING_FIELD(tableSpace);
COPY_NODE_FIELD(indexParams);
+ COPY_NODE_FIELD(options);
+ COPY_STRING_FIELD(src_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;
}
return newnode;
}
-static RemoveAggrStmt *
-_copyRemoveAggrStmt(RemoveAggrStmt *from)
-{
- RemoveAggrStmt *newnode = makeNode(RemoveAggrStmt);
-
- COPY_NODE_FIELD(aggname);
- COPY_NODE_FIELD(aggtype);
- COPY_SCALAR_FIELD(behavior);
-
- return newnode;
-}
-
static RemoveFuncStmt *
_copyRemoveFuncStmt(RemoveFuncStmt *from)
{
RemoveFuncStmt *newnode = makeNode(RemoveFuncStmt);
- COPY_NODE_FIELD(funcname);
+ COPY_SCALAR_FIELD(kind);
+ COPY_NODE_FIELD(name);
COPY_NODE_FIELD(args);
COPY_SCALAR_FIELD(behavior);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
-static RemoveOperStmt *
-_copyRemoveOperStmt(RemoveOperStmt *from)
+static RemoveOpClassStmt *
+_copyRemoveOpClassStmt(RemoveOpClassStmt *from)
{
- RemoveOperStmt *newnode = makeNode(RemoveOperStmt);
+ RemoveOpClassStmt *newnode = makeNode(RemoveOpClassStmt);
- COPY_NODE_FIELD(opname);
- COPY_NODE_FIELD(args);
+ COPY_NODE_FIELD(opclassname);
+ COPY_STRING_FIELD(amname);
COPY_SCALAR_FIELD(behavior);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
-static RemoveOpClassStmt *
-_copyRemoveOpClassStmt(RemoveOpClassStmt *from)
+static RemoveOpFamilyStmt *
+_copyRemoveOpFamilyStmt(RemoveOpFamilyStmt *from)
{
- RemoveOpClassStmt *newnode = makeNode(RemoveOpClassStmt);
+ RemoveOpFamilyStmt *newnode = makeNode(RemoveOpFamilyStmt);
- COPY_NODE_FIELD(opclassname);
+ COPY_NODE_FIELD(opfamilyname);
COPY_STRING_FIELD(amname);
COPY_SCALAR_FIELD(behavior);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
return newnode;
}
+static CreateEnumStmt *
+_copyCreateEnumStmt(CreateEnumStmt *from)
+{
+ CreateEnumStmt *newnode = makeNode(CreateEnumStmt);
+
+ COPY_NODE_FIELD(typename);
+ COPY_NODE_FIELD(vals);
+
+ return newnode;
+}
+
static ViewStmt *
_copyViewStmt(ViewStmt *from)
{
CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt);
COPY_NODE_FIELD(opclassname);
+ COPY_NODE_FIELD(opfamilyname);
COPY_STRING_FIELD(amname);
COPY_NODE_FIELD(datatype);
COPY_NODE_FIELD(items);
COPY_NODE_FIELD(args);
COPY_SCALAR_FIELD(number);
COPY_SCALAR_FIELD(recheck);
+ COPY_NODE_FIELD(class_args);
COPY_NODE_FIELD(storedtype);
return newnode;
}
+static CreateOpFamilyStmt *
+_copyCreateOpFamilyStmt(CreateOpFamilyStmt *from)
+{
+ CreateOpFamilyStmt *newnode = makeNode(CreateOpFamilyStmt);
+
+ COPY_NODE_FIELD(opfamilyname);
+ COPY_STRING_FIELD(amname);
+
+ return newnode;
+}
+
+static AlterOpFamilyStmt *
+_copyAlterOpFamilyStmt(AlterOpFamilyStmt *from)
+{
+ AlterOpFamilyStmt *newnode = makeNode(AlterOpFamilyStmt);
+
+ COPY_NODE_FIELD(opfamilyname);
+ COPY_STRING_FIELD(amname);
+ COPY_SCALAR_FIELD(isDrop);
+ COPY_NODE_FIELD(items);
+
+ return newnode;
+}
+
static CreatedbStmt *
_copyCreatedbStmt(CreatedbStmt *from)
{
AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt);
COPY_STRING_FIELD(dbname);
- COPY_STRING_FIELD(variable);
- COPY_NODE_FIELD(value);
+ COPY_NODE_FIELD(setstmt);
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);
{
VariableSetStmt *newnode = makeNode(VariableSetStmt);
+ COPY_SCALAR_FIELD(kind);
COPY_STRING_FIELD(name);
COPY_NODE_FIELD(args);
COPY_SCALAR_FIELD(is_local);
return newnode;
}
-static VariableResetStmt *
-_copyVariableResetStmt(VariableResetStmt *from)
+static DiscardStmt *
+_copyDiscardStmt(DiscardStmt *from)
{
- VariableResetStmt *newnode = makeNode(VariableResetStmt);
+ DiscardStmt *newnode = makeNode(DiscardStmt);
- COPY_STRING_FIELD(name);
+ COPY_SCALAR_FIELD(target);
return newnode;
}
DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt);
COPY_STRING_FIELD(tablespacename);
+ COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
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;
}
AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt);
COPY_STRING_FIELD(role);
- COPY_STRING_FIELD(variable);
- COPY_NODE_FIELD(value);
+ COPY_NODE_FIELD(setstmt);
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_NODE_FIELD(argtype_oids);
COPY_NODE_FIELD(query);
return newnode;
COPY_STRING_FIELD(name);
COPY_NODE_FIELD(into);
- COPY_SCALAR_FIELD(into_contains_oids);
- COPY_SCALAR_FIELD(into_has_oids);
- COPY_SCALAR_FIELD(into_on_commit);
- COPY_STRING_FIELD(into_tbl_space);
COPY_NODE_FIELD(params);
return newnode;
}
static DropOwnedStmt *
-_copyDropOwnedStmt(DropOwnedStmt * from)
+_copyDropOwnedStmt(DropOwnedStmt *from)
{
DropOwnedStmt *newnode = makeNode(DropOwnedStmt);
}
static ReassignOwnedStmt *
-_copyReassignOwnedStmt(ReassignOwnedStmt * from)
+_copyReassignOwnedStmt(ReassignOwnedStmt *from)
{
ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt);
/*
* PLAN NODES
*/
+ case T_PlannedStmt:
+ retval = _copyPlannedStmt(from);
+ break;
case T_Plan:
retval = _copyPlan(from);
break;
case T_FunctionScan:
retval = _copyFunctionScan(from);
break;
+ case T_ValuesScan:
+ retval = _copyValuesScan(from);
+ break;
case T_Join:
retval = _copyJoin(from);
break;
case T_RangeVar:
retval = _copyRangeVar(from);
break;
+ case T_IntoClause:
+ retval = _copyIntoClause(from);
+ break;
case T_Var:
retval = _copyVar(from);
break;
case T_RelabelType:
retval = _copyRelabelType(from);
break;
+ case T_CoerceViaIO:
+ retval = _copyCoerceViaIO(from);
+ break;
+ case T_ArrayCoerceExpr:
+ retval = _copyArrayCoerceExpr(from);
+ break;
case T_ConvertRowtypeExpr:
retval = _copyConvertRowtypeExpr(from);
break;
case T_MinMaxExpr:
retval = _copyMinMaxExpr(from);
break;
+ case T_XmlExpr:
+ retval = _copyXmlExpr(from);
+ break;
case T_NullIfExpr:
retval = _copyNullIfExpr(from);
break;
case T_SetToDefault:
retval = _copySetToDefault(from);
break;
+ case T_CurrentOfExpr:
+ retval = _copyCurrentOfExpr(from);
+ break;
case T_TargetEntry:
retval = _copyTargetEntry(from);
break;
/*
* RELATION NODES
*/
- case T_PathKeyItem:
- retval = _copyPathKeyItem(from);
+ case T_PathKey:
+ retval = _copyPathKey(from);
break;
case T_RestrictInfo:
retval = _copyRestrictInfo(from);
case T_AlterFunctionStmt:
retval = _copyAlterFunctionStmt(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_RemoveOpClassStmt:
retval = _copyRemoveOpClassStmt(from);
break;
+ case T_RemoveOpFamilyStmt:
+ retval = _copyRemoveOpFamilyStmt(from);
+ break;
case T_RenameStmt:
retval = _copyRenameStmt(from);
break;
case T_CompositeTypeStmt:
retval = _copyCompositeTypeStmt(from);
break;
+ case T_CreateEnumStmt:
+ retval = _copyCreateEnumStmt(from);
+ break;
case T_ViewStmt:
retval = _copyViewStmt(from);
break;
case T_CreateOpClassItem:
retval = _copyCreateOpClassItem(from);
break;
+ case T_CreateOpFamilyStmt:
+ retval = _copyCreateOpFamilyStmt(from);
+ break;
+ case T_AlterOpFamilyStmt:
+ retval = _copyAlterOpFamilyStmt(from);
+ break;
case T_CreatedbStmt:
retval = _copyCreatedbStmt(from);
break;
case T_VariableShowStmt:
retval = _copyVariableShowStmt(from);
break;
- case T_VariableResetStmt:
- retval = _copyVariableResetStmt(from);
+ case T_DiscardStmt:
+ retval = _copyDiscardStmt(from);
break;
case T_CreateTableSpaceStmt:
retval = _copyCreateTableSpaceStmt(from);
case T_GroupClause:
retval = _copyGroupClause(from);
break;
+ case T_RowMarkClause:
+ retval = _copyRowMarkClause(from);
+ break;
case T_FkConstraint:
retval = _copyFkConstraint(from);
break;
case T_FuncWithArgs:
retval = _copyFuncWithArgs(from);
break;
+ case T_XmlSerialize:
+ retval = _copyXmlSerialize(from);
+ break;
default:
elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));
projects / postgresql / blobdiff