X-Git-Url: https://granicus.if.org/sourcecode?a=blobdiff_plain;f=src%2Fbackend%2Fnodes%2Fcopyfuncs.c;h=c6393effcd649006f5c3519b58059b08a6767736;hb=82d8ab6fc4c1a0330c91022728e1e766db207069;hp=f37daaf3a6f0a53b4ed70b0af31dcfcf7e458785;hpb=f2f5b05655afa80377757a2c335c01b28de24429;p=postgresql diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index f37daaf3a6..c6393effcd 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -11,18 +11,17 @@ * 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" @@ -65,6 +64,31 @@ * **************************************************************** */ +/* + * _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 * @@ -85,7 +109,6 @@ CopyPlanFields(Plan *from, Plan *newnode) COPY_NODE_FIELD(initPlan); COPY_BITMAPSET_FIELD(extParam); COPY_BITMAPSET_FIELD(allParam); - COPY_SCALAR_FIELD(nParamExec); } /* @@ -347,6 +370,7 @@ _copySubqueryScan(SubqueryScan *from) * copy remainder of node */ COPY_NODE_FIELD(subplan); + COPY_NODE_FIELD(subrtable); return newnode; } @@ -364,6 +388,35 @@ _copyFunctionScan(FunctionScan *from) */ 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; } @@ -424,6 +477,7 @@ static MergeJoin * _copyMergeJoin(MergeJoin *from) { MergeJoin *newnode = makeNode(MergeJoin); + int numCols; /* * copy node superclass fields @@ -434,6 +488,10 @@ _copyMergeJoin(MergeJoin *from) * 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; } @@ -493,6 +551,7 @@ _copySort(Sort *from) 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; } @@ -510,6 +569,7 @@ _copyGroup(Group *from) COPY_SCALAR_FIELD(numCols); COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber)); + COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid)); return newnode; } @@ -527,7 +587,10 @@ _copyAgg(Agg *from) 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; @@ -551,6 +614,7 @@ _copyUnique(Unique *from) */ COPY_SCALAR_FIELD(numCols); COPY_POINTER_FIELD(uniqColIdx, from->numCols * sizeof(AttrNumber)); + COPY_POINTER_FIELD(uniqOperators, from->numCols * sizeof(Oid)); return newnode; } @@ -594,6 +658,7 @@ _copySetOp(SetOp *from) 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; @@ -658,6 +723,23 @@ _copyRangeVar(RangeVar *from) 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 @@ -693,6 +775,7 @@ _copyConst(Const *from) Const *newnode = makeNode(Const); COPY_SCALAR_FIELD(consttype); + COPY_SCALAR_FIELD(consttypmod); COPY_SCALAR_FIELD(constlen); if (from->constbyval || from->constisnull) @@ -729,8 +812,8 @@ _copyParam(Param *from) COPY_SCALAR_FIELD(paramkind); COPY_SCALAR_FIELD(paramid); - COPY_STRING_FIELD(paramname); COPY_SCALAR_FIELD(paramtype); + COPY_SCALAR_FIELD(paramtypmod); return newnode; } @@ -745,7 +828,7 @@ _copyAggref(Aggref *from) 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); @@ -761,9 +844,9 @@ _copyArrayRef(ArrayRef *from) { 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); @@ -880,9 +963,8 @@ _copySubPlan(SubPlan *from) 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); @@ -940,6 +1022,39 @@ _copyRelabelType(RelabelType *from) 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 */ @@ -1036,11 +1151,11 @@ _copyRowExpr(RowExpr *from) 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); @@ -1076,6 +1191,26 @@ _copyMinMaxExpr(MinMaxExpr *from) 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) */ @@ -1165,6 +1300,21 @@ _copySetToDefault(SetToDefault *from) 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 */ @@ -1240,15 +1390,18 @@ _copyFromExpr(FromExpr *from) */ /* - * _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; } @@ -1265,25 +1418,25 @@ _copyRestrictInfo(RestrictInfo *from) 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); @@ -1301,8 +1454,11 @@ _copyOuterJoinInfo(OuterJoinInfo *from) 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; } @@ -1318,6 +1474,7 @@ _copyInClauseInfo(InClauseInfo *from) COPY_BITMAPSET_FIELD(lefthand); COPY_BITMAPSET_FIELD(righthand); COPY_NODE_FIELD(sub_targetlist); + COPY_NODE_FIELD(in_operators); return newnode; } @@ -1355,7 +1512,9 @@ _copyRangeTblEntry(RangeTblEntry *from) 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); @@ -1394,6 +1553,7 @@ _copySortClause(SortClause *from) COPY_SCALAR_FIELD(tleSortGroupRef); COPY_SCALAR_FIELD(sortop); + COPY_SCALAR_FIELD(nulls_first); return newnode; } @@ -1405,6 +1565,19 @@ _copyGroupClause(GroupClause *from) 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; } @@ -1418,6 +1591,7 @@ _copyAExpr(A_Expr *from) COPY_NODE_FIELD(name); COPY_NODE_FIELD(lexpr); COPY_NODE_FIELD(rexpr); + COPY_SCALAR_FIELD(location); return newnode; } @@ -1428,6 +1602,7 @@ _copyColumnRef(ColumnRef *from) ColumnRef *newnode = makeNode(ColumnRef); COPY_NODE_FIELD(fields); + COPY_SCALAR_FIELD(location); return newnode; } @@ -1482,6 +1657,7 @@ _copyFuncCall(FuncCall *from) COPY_NODE_FIELD(args); COPY_SCALAR_FIELD(agg_star); COPY_SCALAR_FIELD(agg_distinct); + COPY_SCALAR_FIELD(location); return newnode; } @@ -1516,6 +1692,7 @@ _copyResTarget(ResTarget *from) COPY_STRING_FIELD(name); COPY_NODE_FIELD(indirection); COPY_NODE_FIELD(val); + COPY_SCALAR_FIELD(location); return newnode; } @@ -1530,8 +1707,10 @@ _copyTypeName(TypeName *from) 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; } @@ -1541,7 +1720,8 @@ _copySortBy(SortBy *from) { 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); @@ -1590,6 +1770,8 @@ _copyIndexElem(IndexElem *from) COPY_STRING_FIELD(name); COPY_NODE_FIELD(expr); COPY_NODE_FIELD(opclass); + COPY_SCALAR_FIELD(ordering); + COPY_SCALAR_FIELD(nulls_ordering); return newnode; } @@ -1607,7 +1789,6 @@ _copyColumnDef(ColumnDef *from) COPY_NODE_FIELD(raw_default); COPY_STRING_FIELD(cooked_default); COPY_NODE_FIELD(constraints); - COPY_NODE_FIELD(support); return newnode; } @@ -1622,6 +1803,7 @@ _copyConstraint(Constraint *from) COPY_NODE_FIELD(raw_expr); COPY_STRING_FIELD(cooked_expr); COPY_NODE_FIELD(keys); + COPY_NODE_FIELD(options); COPY_STRING_FIELD(indexspace); return newnode; @@ -1645,7 +1827,19 @@ _copyLockingClause(LockingClause *from) 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; } @@ -1660,26 +1854,21 @@ _copyQuery(Query *from) 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; } @@ -1691,8 +1880,8 @@ _copyInsertStmt(InsertStmt *from) COPY_NODE_FIELD(relation); COPY_NODE_FIELD(cols); - COPY_NODE_FIELD(targetList); COPY_NODE_FIELD(selectStmt); + COPY_NODE_FIELD(returningList); return newnode; } @@ -1703,8 +1892,9 @@ _copyDeleteStmt(DeleteStmt *from) 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; } @@ -1718,6 +1908,7 @@ _copyUpdateStmt(UpdateStmt *from) COPY_NODE_FIELD(targetList); COPY_NODE_FIELD(whereClause); COPY_NODE_FIELD(fromClause); + COPY_NODE_FIELD(returningList); return newnode; } @@ -1728,16 +1919,13 @@ _copySelectStmt(SelectStmt *from) 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); @@ -1760,6 +1948,7 @@ _copySetOperationStmt(SetOperationStmt *from) COPY_NODE_FIELD(larg); COPY_NODE_FIELD(rarg); COPY_NODE_FIELD(colTypes); + COPY_NODE_FIELD(colTypmods); return newnode; } @@ -1895,6 +2084,7 @@ _copyCopyStmt(CopyStmt *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); @@ -1912,7 +2102,7 @@ _copyCreateStmt(CreateStmt *from) 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); @@ -1925,7 +2115,7 @@ _copyInhRelation(InhRelation *from) InhRelation *newnode = makeNode(InhRelation); COPY_NODE_FIELD(relation); - COPY_SCALAR_FIELD(including_defaults); + COPY_NODE_FIELD(options); return newnode; } @@ -1936,7 +2126,9 @@ _copyDefineStmt(DefineStmt *from) 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; @@ -2002,11 +2194,13 @@ _copyIndexStmt(IndexStmt *from) 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; } @@ -2049,50 +2243,42 @@ _copyAlterFunctionStmt(AlterFunctionStmt *from) 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; } @@ -2211,6 +2397,17 @@ _copyCompositeTypeStmt(CompositeTypeStmt *from) 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) { @@ -2252,6 +2449,7 @@ _copyCreateOpClassStmt(CreateOpClassStmt *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); @@ -2270,11 +2468,36 @@ _copyCreateOpClassItem(CreateOpClassItem *from) 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) { @@ -2303,8 +2526,7 @@ _copyAlterDatabaseSetStmt(AlterDatabaseSetStmt *from) AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt); COPY_STRING_FIELD(dbname); - COPY_STRING_FIELD(variable); - COPY_NODE_FIELD(value); + COPY_NODE_FIELD(setstmt); return newnode; } @@ -2328,8 +2550,8 @@ _copyVacuumStmt(VacuumStmt *from) 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); @@ -2375,6 +2597,7 @@ _copyVariableSetStmt(VariableSetStmt *from) { VariableSetStmt *newnode = makeNode(VariableSetStmt); + COPY_SCALAR_FIELD(kind); COPY_STRING_FIELD(name); COPY_NODE_FIELD(args); COPY_SCALAR_FIELD(is_local); @@ -2392,12 +2615,12 @@ _copyVariableShowStmt(VariableShowStmt *from) 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; } @@ -2420,6 +2643,7 @@ _copyDropTableSpaceStmt(DropTableSpaceStmt *from) DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt); COPY_STRING_FIELD(tablespacename); + COPY_SCALAR_FIELD(missing_ok); return newnode; } @@ -2453,6 +2677,7 @@ _copyDropPropertyStmt(DropPropertyStmt *from) COPY_STRING_FIELD(property); COPY_SCALAR_FIELD(removeType); COPY_SCALAR_FIELD(behavior); + COPY_SCALAR_FIELD(missing_ok); return newnode; } @@ -2477,6 +2702,7 @@ _copyDropPLangStmt(DropPLangStmt *from) COPY_STRING_FIELD(plname); COPY_SCALAR_FIELD(behavior); + COPY_SCALAR_FIELD(missing_ok); return newnode; } @@ -2511,8 +2737,7 @@ _copyAlterRoleSetStmt(AlterRoleSetStmt *from) AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt); COPY_STRING_FIELD(role); - COPY_STRING_FIELD(variable); - COPY_NODE_FIELD(value); + COPY_NODE_FIELD(setstmt); return newnode; } @@ -2612,6 +2837,7 @@ _copyDropCastStmt(DropCastStmt *from) COPY_NODE_FIELD(sourcetype); COPY_NODE_FIELD(targettype); COPY_SCALAR_FIELD(behavior); + COPY_SCALAR_FIELD(missing_ok); return newnode; } @@ -2623,7 +2849,6 @@ _copyPrepareStmt(PrepareStmt *from) COPY_STRING_FIELD(name); COPY_NODE_FIELD(argtypes); - COPY_NODE_FIELD(argtype_oids); COPY_NODE_FIELD(query); return newnode; @@ -2636,10 +2861,6 @@ _copyExecuteStmt(ExecuteStmt *from) 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; @@ -2656,7 +2877,7 @@ _copyDeallocateStmt(DeallocateStmt *from) } static DropOwnedStmt * -_copyDropOwnedStmt(DropOwnedStmt * from) +_copyDropOwnedStmt(DropOwnedStmt *from) { DropOwnedStmt *newnode = makeNode(DropOwnedStmt); @@ -2667,7 +2888,7 @@ _copyDropOwnedStmt(DropOwnedStmt * from) } static ReassignOwnedStmt * -_copyReassignOwnedStmt(ReassignOwnedStmt * from) +_copyReassignOwnedStmt(ReassignOwnedStmt *from) { ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt); @@ -2771,6 +2992,9 @@ copyObject(void *from) /* * PLAN NODES */ + case T_PlannedStmt: + retval = _copyPlannedStmt(from); + break; case T_Plan: retval = _copyPlan(from); break; @@ -2810,6 +3034,9 @@ copyObject(void *from) case T_FunctionScan: retval = _copyFunctionScan(from); break; + case T_ValuesScan: + retval = _copyValuesScan(from); + break; case T_Join: retval = _copyJoin(from); break; @@ -2856,6 +3083,9 @@ copyObject(void *from) case T_RangeVar: retval = _copyRangeVar(from); break; + case T_IntoClause: + retval = _copyIntoClause(from); + break; case T_Var: retval = _copyVar(from); break; @@ -2901,6 +3131,12 @@ copyObject(void *from) 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; @@ -2928,6 +3164,9 @@ copyObject(void *from) case T_MinMaxExpr: retval = _copyMinMaxExpr(from); break; + case T_XmlExpr: + retval = _copyXmlExpr(from); + break; case T_NullIfExpr: retval = _copyNullIfExpr(from); break; @@ -2946,6 +3185,9 @@ copyObject(void *from) case T_SetToDefault: retval = _copySetToDefault(from); break; + case T_CurrentOfExpr: + retval = _copyCurrentOfExpr(from); + break; case T_TargetEntry: retval = _copyTargetEntry(from); break; @@ -2962,8 +3204,8 @@ copyObject(void *from) /* * RELATION NODES */ - case T_PathKeyItem: - retval = _copyPathKeyItem(from); + case T_PathKey: + retval = _copyPathKey(from); break; case T_RestrictInfo: retval = _copyRestrictInfo(from); @@ -3086,18 +3328,15 @@ copyObject(void *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; @@ -3125,6 +3364,9 @@ copyObject(void *from) case T_CompositeTypeStmt: retval = _copyCompositeTypeStmt(from); break; + case T_CreateEnumStmt: + retval = _copyCreateEnumStmt(from); + break; case T_ViewStmt: retval = _copyViewStmt(from); break; @@ -3140,6 +3382,12 @@ copyObject(void *from) 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; @@ -3170,8 +3418,8 @@ copyObject(void *from) 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); @@ -3306,6 +3554,9 @@ copyObject(void *from) case T_GroupClause: retval = _copyGroupClause(from); break; + case T_RowMarkClause: + retval = _copyRowMarkClause(from); + break; case T_FkConstraint: retval = _copyFkConstraint(from); break; @@ -3315,6 +3566,9 @@ copyObject(void *from) case T_FuncWithArgs: retval = _copyFuncWithArgs(from); break; + case T_XmlSerialize: + retval = _copyXmlSerialize(from); + break; default: elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));