Change the planner-to-executor API so that the planner tells the executor

[postgresql] / src / backend / nodes / equalfuncs.c

diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
index fa27e5871b986a06ee9cd74cd6175d4db4c49bde..fafd8ae5468a058b4880e915559a00fcc99b324f 100644 (file)
--- a/src/backend/nodes/equalfuncs.c
+++ b/src/backend/nodes/equalfuncs.c
@@ -14,19 +14,17 @@
  * either.     This might need to be fixed someday.
  *
  *
- * Portions Copyright (c) 1996-2005, 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/equalfuncs.c,v 1.256 2005/11/21 12:49:31 alvherre Exp $
+ *       $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.295 2007/01/10 18:06:03 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
 
 #include "postgres.h"
 
-#include "nodes/params.h"
-#include "nodes/parsenodes.h"
 #include "nodes/relation.h"
 #include "utils/datum.h"
 
@@ -147,21 +145,9 @@ static bool
 _equalParam(Param *a, Param *b)
 {
        COMPARE_SCALAR_FIELD(paramkind);
+       COMPARE_SCALAR_FIELD(paramid);
        COMPARE_SCALAR_FIELD(paramtype);
-
-       switch (a->paramkind)
-       {
-               case PARAM_NAMED:
-                       COMPARE_STRING_FIELD(paramname);
-                       break;
-               case PARAM_NUM:
-               case PARAM_EXEC:
-                       COMPARE_SCALAR_FIELD(paramid);
-                       break;
-               default:
-                       elog(ERROR, "unrecognized paramkind: %d",
-                                a->paramkind);
-       }
+       COMPARE_SCALAR_FIELD(paramtypmod);
 
        return true;
 }
@@ -171,7 +157,7 @@ _equalAggref(Aggref *a, Aggref *b)
 {
        COMPARE_SCALAR_FIELD(aggfnoid);
        COMPARE_SCALAR_FIELD(aggtype);
-       COMPARE_NODE_FIELD(target);
+       COMPARE_NODE_FIELD(args);
        COMPARE_SCALAR_FIELD(agglevelsup);
        COMPARE_SCALAR_FIELD(aggstar);
        COMPARE_SCALAR_FIELD(aggdistinct);
@@ -295,10 +281,8 @@ static bool
 _equalSubLink(SubLink *a, SubLink *b)
 {
        COMPARE_SCALAR_FIELD(subLinkType);
-       COMPARE_SCALAR_FIELD(useOr);
-       COMPARE_NODE_FIELD(lefthand);
+       COMPARE_NODE_FIELD(testexpr);
        COMPARE_NODE_FIELD(operName);
-       COMPARE_NODE_FIELD(operOids);
        COMPARE_NODE_FIELD(subselect);
 
        return true;
@@ -308,8 +292,7 @@ static bool
 _equalSubPlan(SubPlan *a, SubPlan *b)
 {
        COMPARE_SCALAR_FIELD(subLinkType);
-       COMPARE_SCALAR_FIELD(useOr);
-       COMPARE_NODE_FIELD(exprs);
+       COMPARE_NODE_FIELD(testexpr);
        COMPARE_NODE_FIELD(paramIds);
        /* should compare plans, but have to settle for comparing plan IDs */
        COMPARE_SCALAR_FIELD(plan_id);
@@ -440,6 +423,18 @@ _equalRowExpr(RowExpr *a, RowExpr *b)
        return true;
 }
 
+static bool
+_equalRowCompareExpr(RowCompareExpr *a, RowCompareExpr *b)
+{
+       COMPARE_SCALAR_FIELD(rctype);
+       COMPARE_NODE_FIELD(opnos);
+       COMPARE_NODE_FIELD(opfamilies);
+       COMPARE_NODE_FIELD(largs);
+       COMPARE_NODE_FIELD(rargs);
+
+       return true;
+}
+
 static bool
 _equalCoalesceExpr(CoalesceExpr *a, CoalesceExpr *b)
 {
@@ -459,6 +454,18 @@ _equalMinMaxExpr(MinMaxExpr *a, MinMaxExpr *b)
        return true;
 }
 
+static bool
+_equalXmlExpr(XmlExpr *a, XmlExpr *b)
+{
+       COMPARE_SCALAR_FIELD(op);
+       COMPARE_STRING_FIELD(name);
+       COMPARE_NODE_FIELD(named_args);
+       COMPARE_NODE_FIELD(arg_names);
+       COMPARE_NODE_FIELD(args);
+
+       return true;
+}
+
 static bool
 _equalNullIfExpr(NullIfExpr *a, NullIfExpr *b)
 {
@@ -593,6 +600,7 @@ _equalPathKeyItem(PathKeyItem *a, PathKeyItem *b)
 {
        COMPARE_NODE_FIELD(key);
        COMPARE_SCALAR_FIELD(sortop);
+       COMPARE_SCALAR_FIELD(nulls_first);
 
        return true;
 }
@@ -613,12 +621,38 @@ _equalRestrictInfo(RestrictInfo *a, RestrictInfo *b)
        return true;
 }
 
+static bool
+_equalOuterJoinInfo(OuterJoinInfo *a, OuterJoinInfo *b)
+{
+       COMPARE_BITMAPSET_FIELD(min_lefthand);
+       COMPARE_BITMAPSET_FIELD(min_righthand);
+       COMPARE_SCALAR_FIELD(is_full_join);
+       COMPARE_SCALAR_FIELD(lhs_strict);
+
+       return true;
+}
+
 static bool
 _equalInClauseInfo(InClauseInfo *a, InClauseInfo *b)
 {
        COMPARE_BITMAPSET_FIELD(lefthand);
        COMPARE_BITMAPSET_FIELD(righthand);
        COMPARE_NODE_FIELD(sub_targetlist);
+       COMPARE_NODE_FIELD(in_operators);
+
+       return true;
+}
+
+static bool
+_equalAppendRelInfo(AppendRelInfo *a, AppendRelInfo *b)
+{
+       COMPARE_SCALAR_FIELD(parent_relid);
+       COMPARE_SCALAR_FIELD(child_relid);
+       COMPARE_SCALAR_FIELD(parent_reltype);
+       COMPARE_SCALAR_FIELD(child_reltype);
+       COMPARE_NODE_FIELD(col_mappings);
+       COMPARE_NODE_FIELD(translated_vars);
+       COMPARE_SCALAR_FIELD(parent_reloid);
 
        return true;
 }
@@ -637,23 +671,25 @@ _equalQuery(Query *a, Query *b)
        COMPARE_NODE_FIELD(utilityStmt);
        COMPARE_SCALAR_FIELD(resultRelation);
        COMPARE_NODE_FIELD(into);
-       COMPARE_SCALAR_FIELD(intoHasOids);
+       COMPARE_NODE_FIELD(intoOptions);
+       COMPARE_SCALAR_FIELD(intoOnCommit);
+       COMPARE_STRING_FIELD(intoTableSpaceName);
        COMPARE_SCALAR_FIELD(hasAggs);
        COMPARE_SCALAR_FIELD(hasSubLinks);
        COMPARE_NODE_FIELD(rtable);
        COMPARE_NODE_FIELD(jointree);
-       COMPARE_NODE_FIELD(rowMarks);
-       COMPARE_SCALAR_FIELD(forUpdate);
-       COMPARE_SCALAR_FIELD(rowNoWait);
        COMPARE_NODE_FIELD(targetList);
+       COMPARE_NODE_FIELD(returningList);
        COMPARE_NODE_FIELD(groupClause);
        COMPARE_NODE_FIELD(havingQual);
        COMPARE_NODE_FIELD(distinctClause);
        COMPARE_NODE_FIELD(sortClause);
        COMPARE_NODE_FIELD(limitOffset);
        COMPARE_NODE_FIELD(limitCount);
+       COMPARE_NODE_FIELD(rowMarks);
        COMPARE_NODE_FIELD(setOperations);
        COMPARE_NODE_FIELD(resultRelations);
+       COMPARE_NODE_FIELD(returningLists);
 
        return true;
 }
@@ -663,8 +699,8 @@ _equalInsertStmt(InsertStmt *a, InsertStmt *b)
 {
        COMPARE_NODE_FIELD(relation);
        COMPARE_NODE_FIELD(cols);
-       COMPARE_NODE_FIELD(targetList);
        COMPARE_NODE_FIELD(selectStmt);
+       COMPARE_NODE_FIELD(returningList);
 
        return true;
 }
@@ -673,8 +709,9 @@ static bool
 _equalDeleteStmt(DeleteStmt *a, DeleteStmt *b)
 {
        COMPARE_NODE_FIELD(relation);
-       COMPARE_NODE_FIELD(whereClause);
        COMPARE_NODE_FIELD(usingClause);
+       COMPARE_NODE_FIELD(whereClause);
+       COMPARE_NODE_FIELD(returningList);
 
        return true;
 }
@@ -686,6 +723,7 @@ _equalUpdateStmt(UpdateStmt *a, UpdateStmt *b)
        COMPARE_NODE_FIELD(targetList);
        COMPARE_NODE_FIELD(whereClause);
        COMPARE_NODE_FIELD(fromClause);
+       COMPARE_NODE_FIELD(returningList);
 
        return true;
 }
@@ -696,12 +734,15 @@ _equalSelectStmt(SelectStmt *a, SelectStmt *b)
        COMPARE_NODE_FIELD(distinctClause);
        COMPARE_NODE_FIELD(into);
        COMPARE_NODE_FIELD(intoColNames);
-       COMPARE_SCALAR_FIELD(intoHasOids);
+       COMPARE_NODE_FIELD(intoOptions);
+       COMPARE_SCALAR_FIELD(intoOnCommit);
+       COMPARE_STRING_FIELD(intoTableSpaceName);
        COMPARE_NODE_FIELD(targetList);
        COMPARE_NODE_FIELD(fromClause);
        COMPARE_NODE_FIELD(whereClause);
        COMPARE_NODE_FIELD(groupClause);
        COMPARE_NODE_FIELD(havingClause);
+       COMPARE_NODE_FIELD(valuesLists);
        COMPARE_NODE_FIELD(sortClause);
        COMPARE_NODE_FIELD(limitOffset);
        COMPARE_NODE_FIELD(limitCount);
@@ -722,6 +763,7 @@ _equalSetOperationStmt(SetOperationStmt *a, SetOperationStmt *b)
        COMPARE_NODE_FIELD(larg);
        COMPARE_NODE_FIELD(rarg);
        COMPARE_NODE_FIELD(colTypes);
+       COMPARE_NODE_FIELD(colTypmods);
 
        return true;
 }
@@ -835,6 +877,7 @@ static bool
 _equalCopyStmt(CopyStmt *a, CopyStmt *b)
 {
        COMPARE_NODE_FIELD(relation);
+       COMPARE_NODE_FIELD(query);
        COMPARE_NODE_FIELD(attlist);
        COMPARE_SCALAR_FIELD(is_from);
        COMPARE_STRING_FIELD(filename);
@@ -850,7 +893,7 @@ _equalCreateStmt(CreateStmt *a, CreateStmt *b)
        COMPARE_NODE_FIELD(tableElts);
        COMPARE_NODE_FIELD(inhRelations);
        COMPARE_NODE_FIELD(constraints);
-       COMPARE_SCALAR_FIELD(hasoids);
+       COMPARE_NODE_FIELD(options);
        COMPARE_SCALAR_FIELD(oncommit);
        COMPARE_STRING_FIELD(tablespacename);
 
@@ -861,7 +904,7 @@ static bool
 _equalInhRelation(InhRelation *a, InhRelation *b)
 {
        COMPARE_NODE_FIELD(relation);
-       COMPARE_SCALAR_FIELD(including_defaults);
+       COMPARE_NODE_FIELD(options);
 
        return true;
 }
@@ -870,7 +913,9 @@ static bool
 _equalDefineStmt(DefineStmt *a, DefineStmt *b)
 {
        COMPARE_SCALAR_FIELD(kind);
+       COMPARE_SCALAR_FIELD(oldstyle);
        COMPARE_NODE_FIELD(defnames);
+       COMPARE_NODE_FIELD(args);
        COMPARE_NODE_FIELD(definition);
 
        return true;
@@ -891,6 +936,7 @@ static bool
 _equalTruncateStmt(TruncateStmt *a, TruncateStmt *b)
 {
        COMPARE_NODE_FIELD(relations);
+       COMPARE_SCALAR_FIELD(behavior);
 
        return true;
 }
@@ -925,11 +971,13 @@ _equalIndexStmt(IndexStmt *a, IndexStmt *b)
        COMPARE_STRING_FIELD(accessMethod);
        COMPARE_STRING_FIELD(tableSpace);
        COMPARE_NODE_FIELD(indexParams);
+       COMPARE_NODE_FIELD(options);
        COMPARE_NODE_FIELD(whereClause);
        COMPARE_NODE_FIELD(rangetable);
        COMPARE_SCALAR_FIELD(unique);
        COMPARE_SCALAR_FIELD(primary);
        COMPARE_SCALAR_FIELD(isconstraint);
+       COMPARE_SCALAR_FIELD(concurrent);
 
        return true;
 }
@@ -966,32 +1014,14 @@ _equalAlterFunctionStmt(AlterFunctionStmt *a, AlterFunctionStmt *b)
        return true;
 }
 
-static bool
-_equalRemoveAggrStmt(RemoveAggrStmt *a, RemoveAggrStmt *b)
-{
-       COMPARE_NODE_FIELD(aggname);
-       COMPARE_NODE_FIELD(aggtype);
-       COMPARE_SCALAR_FIELD(behavior);
-
-       return true;
-}
-
 static bool
 _equalRemoveFuncStmt(RemoveFuncStmt *a, RemoveFuncStmt *b)
 {
-       COMPARE_NODE_FIELD(funcname);
-       COMPARE_NODE_FIELD(args);
-       COMPARE_SCALAR_FIELD(behavior);
-
-       return true;
-}
-
-static bool
-_equalRemoveOperStmt(RemoveOperStmt *a, RemoveOperStmt *b)
-{
-       COMPARE_NODE_FIELD(opname);
+       COMPARE_SCALAR_FIELD(kind);
+       COMPARE_NODE_FIELD(name);
        COMPARE_NODE_FIELD(args);
        COMPARE_SCALAR_FIELD(behavior);
+       COMPARE_SCALAR_FIELD(missing_ok);
 
        return true;
 }
@@ -1002,6 +1032,7 @@ _equalRemoveOpClassStmt(RemoveOpClassStmt *a, RemoveOpClassStmt *b)
        COMPARE_NODE_FIELD(opclassname);
        COMPARE_STRING_FIELD(amname);
        COMPARE_SCALAR_FIELD(behavior);
+       COMPARE_SCALAR_FIELD(missing_ok);
 
        return true;
 }
@@ -1135,6 +1166,7 @@ static bool
 _equalCreateOpClassStmt(CreateOpClassStmt *a, CreateOpClassStmt *b)
 {
        COMPARE_NODE_FIELD(opclassname);
+       COMPARE_NODE_FIELD(opfamilyname);
        COMPARE_STRING_FIELD(amname);
        COMPARE_NODE_FIELD(datatype);
        COMPARE_NODE_FIELD(items);
@@ -1188,6 +1220,7 @@ static bool
 _equalDropdbStmt(DropdbStmt *a, DropdbStmt *b)
 {
        COMPARE_STRING_FIELD(dbname);
+       COMPARE_SCALAR_FIELD(missing_ok);
 
        return true;
 }
@@ -1198,8 +1231,8 @@ _equalVacuumStmt(VacuumStmt *a, VacuumStmt *b)
        COMPARE_SCALAR_FIELD(vacuum);
        COMPARE_SCALAR_FIELD(full);
        COMPARE_SCALAR_FIELD(analyze);
-       COMPARE_SCALAR_FIELD(freeze);
        COMPARE_SCALAR_FIELD(verbose);
+       COMPARE_SCALAR_FIELD(freeze_min_age);
        COMPARE_NODE_FIELD(relation);
        COMPARE_NODE_FIELD(va_cols);
 
@@ -1274,6 +1307,7 @@ static bool
 _equalDropTableSpaceStmt(DropTableSpaceStmt *a, DropTableSpaceStmt *b)
 {
        COMPARE_STRING_FIELD(tablespacename);
+       COMPARE_SCALAR_FIELD(missing_ok);
 
        return true;
 }
@@ -1304,6 +1338,7 @@ _equalDropPropertyStmt(DropPropertyStmt *a, DropPropertyStmt *b)
        COMPARE_STRING_FIELD(property);
        COMPARE_SCALAR_FIELD(removeType);
        COMPARE_SCALAR_FIELD(behavior);
+       COMPARE_SCALAR_FIELD(missing_ok);
 
        return true;
 }
@@ -1324,6 +1359,7 @@ _equalDropPLangStmt(DropPLangStmt *a, DropPLangStmt *b)
 {
        COMPARE_STRING_FIELD(plname);
        COMPARE_SCALAR_FIELD(behavior);
+       COMPARE_SCALAR_FIELD(missing_ok);
 
        return true;
 }
@@ -1362,6 +1398,7 @@ static bool
 _equalDropRoleStmt(DropRoleStmt *a, DropRoleStmt *b)
 {
        COMPARE_NODE_FIELD(roles);
+       COMPARE_SCALAR_FIELD(missing_ok);
 
        return true;
 }
@@ -1436,6 +1473,7 @@ _equalDropCastStmt(DropCastStmt *a, DropCastStmt *b)
        COMPARE_NODE_FIELD(sourcetype);
        COMPARE_NODE_FIELD(targettype);
        COMPARE_SCALAR_FIELD(behavior);
+       COMPARE_SCALAR_FIELD(missing_ok);
 
        return true;
 }
@@ -1456,6 +1494,9 @@ _equalExecuteStmt(ExecuteStmt *a, ExecuteStmt *b)
 {
        COMPARE_STRING_FIELD(name);
        COMPARE_NODE_FIELD(into);
+       COMPARE_NODE_FIELD(intoOptions);
+       COMPARE_SCALAR_FIELD(into_on_commit);
+       COMPARE_STRING_FIELD(into_tbl_space);
        COMPARE_NODE_FIELD(params);
 
        return true;
@@ -1494,6 +1535,7 @@ _equalAExpr(A_Expr *a, A_Expr *b)
        COMPARE_NODE_FIELD(name);
        COMPARE_NODE_FIELD(lexpr);
        COMPARE_NODE_FIELD(rexpr);
+       COMPARE_SCALAR_FIELD(location);
 
        return true;
 }
@@ -1502,6 +1544,7 @@ static bool
 _equalColumnRef(ColumnRef *a, ColumnRef *b)
 {
        COMPARE_NODE_FIELD(fields);
+       COMPARE_SCALAR_FIELD(location);
 
        return true;
 }
@@ -1531,6 +1574,7 @@ _equalFuncCall(FuncCall *a, FuncCall *b)
        COMPARE_NODE_FIELD(args);
        COMPARE_SCALAR_FIELD(agg_star);
        COMPARE_SCALAR_FIELD(agg_distinct);
+       COMPARE_SCALAR_FIELD(location);
 
        return true;
 }
@@ -1559,6 +1603,7 @@ _equalResTarget(ResTarget *a, ResTarget *b)
        COMPARE_STRING_FIELD(name);
        COMPARE_NODE_FIELD(indirection);
        COMPARE_NODE_FIELD(val);
+       COMPARE_SCALAR_FIELD(location);
 
        return true;
 }
@@ -1571,8 +1616,10 @@ _equalTypeName(TypeName *a, TypeName *b)
        COMPARE_SCALAR_FIELD(timezone);
        COMPARE_SCALAR_FIELD(setof);
        COMPARE_SCALAR_FIELD(pct_type);
-       COMPARE_SCALAR_FIELD(typmod);
+       COMPARE_NODE_FIELD(typmods);
+       COMPARE_SCALAR_FIELD(typemod);
        COMPARE_NODE_FIELD(arrayBounds);
+       COMPARE_SCALAR_FIELD(location);
 
        return true;
 }
@@ -1589,7 +1636,8 @@ _equalTypeCast(TypeCast *a, TypeCast *b)
 static bool
 _equalSortBy(SortBy *a, SortBy *b)
 {
-       COMPARE_SCALAR_FIELD(sortby_kind);
+       COMPARE_SCALAR_FIELD(sortby_dir);
+       COMPARE_SCALAR_FIELD(sortby_nulls);
        COMPARE_NODE_FIELD(useOp);
        COMPARE_NODE_FIELD(node);
 
@@ -1621,6 +1669,8 @@ _equalIndexElem(IndexElem *a, IndexElem *b)
        COMPARE_STRING_FIELD(name);
        COMPARE_NODE_FIELD(expr);
        COMPARE_NODE_FIELD(opclass);
+       COMPARE_SCALAR_FIELD(ordering);
+       COMPARE_SCALAR_FIELD(nulls_ordering);
 
        return true;
 }
@@ -1636,7 +1686,6 @@ _equalColumnDef(ColumnDef *a, ColumnDef *b)
        COMPARE_NODE_FIELD(raw_default);
        COMPARE_STRING_FIELD(cooked_default);
        COMPARE_NODE_FIELD(constraints);
-       COMPARE_NODE_FIELD(support);
 
        return true;
 }
@@ -1649,6 +1698,7 @@ _equalConstraint(Constraint *a, Constraint *b)
        COMPARE_NODE_FIELD(raw_expr);
        COMPARE_STRING_FIELD(cooked_expr);
        COMPARE_NODE_FIELD(keys);
+       COMPARE_NODE_FIELD(options);
        COMPARE_STRING_FIELD(indexspace);
 
        return true;
@@ -1668,7 +1718,7 @@ _equalLockingClause(LockingClause *a, LockingClause *b)
 {
        COMPARE_NODE_FIELD(lockedRels);
        COMPARE_SCALAR_FIELD(forUpdate);
-       COMPARE_SCALAR_FIELD(nowait);
+       COMPARE_SCALAR_FIELD(noWait);
 
        return true;
 }
@@ -1680,7 +1730,9 @@ _equalRangeTblEntry(RangeTblEntry *a, RangeTblEntry *b)
        COMPARE_SCALAR_FIELD(relid);
        COMPARE_NODE_FIELD(subquery);
        COMPARE_NODE_FIELD(funcexpr);
-       COMPARE_NODE_FIELD(coldeflist);
+       COMPARE_NODE_FIELD(funccoltypes);
+       COMPARE_NODE_FIELD(funccoltypmods);
+       COMPARE_NODE_FIELD(values_lists);
        COMPARE_SCALAR_FIELD(jointype);
        COMPARE_NODE_FIELD(joinaliasvars);
        COMPARE_NODE_FIELD(alias);
@@ -1698,6 +1750,17 @@ _equalSortClause(SortClause *a, SortClause *b)
 {
        COMPARE_SCALAR_FIELD(tleSortGroupRef);
        COMPARE_SCALAR_FIELD(sortop);
+       COMPARE_SCALAR_FIELD(nulls_first);
+
+       return true;
+}
+
+static bool
+_equalRowMarkClause(RowMarkClause *a, RowMarkClause *b)
+{
+       COMPARE_SCALAR_FIELD(rti);
+       COMPARE_SCALAR_FIELD(forUpdate);
+       COMPARE_SCALAR_FIELD(noWait);
 
        return true;
 }
@@ -1907,12 +1970,18 @@ equal(void *a, void *b)
                case T_RowExpr:
                        retval = _equalRowExpr(a, b);
                        break;
+               case T_RowCompareExpr:
+                       retval = _equalRowCompareExpr(a, b);
+                       break;
                case T_CoalesceExpr:
                        retval = _equalCoalesceExpr(a, b);
                        break;
                case T_MinMaxExpr:
                        retval = _equalMinMaxExpr(a, b);
                        break;
+               case T_XmlExpr:
+                       retval = _equalXmlExpr(a, b);
+                       break;
                case T_NullIfExpr:
                        retval = _equalNullIfExpr(a, b);
                        break;
@@ -1953,9 +2022,15 @@ equal(void *a, void *b)
                case T_RestrictInfo:
                        retval = _equalRestrictInfo(a, b);
                        break;
+               case T_OuterJoinInfo:
+                       retval = _equalOuterJoinInfo(a, b);
+                       break;
                case T_InClauseInfo:
                        retval = _equalInClauseInfo(a, b);
                        break;
+               case T_AppendRelInfo:
+                       retval = _equalAppendRelInfo(a, b);
+                       break;
                case T_List:
                case T_IntList:
                case T_OidList:
@@ -2051,15 +2126,9 @@ equal(void *a, void *b)
                case T_AlterFunctionStmt:
                        retval = _equalAlterFunctionStmt(a, b);
                        break;
-               case T_RemoveAggrStmt:
-                       retval = _equalRemoveAggrStmt(a, b);
-                       break;
                case T_RemoveFuncStmt:
                        retval = _equalRemoveFuncStmt(a, b);
                        break;
-               case T_RemoveOperStmt:
-                       retval = _equalRemoveOperStmt(a, b);
-                       break;
                case T_RemoveOpClassStmt:
                        retval = _equalRemoveOpClassStmt(a, b);
                        break;
@@ -2273,6 +2342,9 @@ equal(void *a, void *b)
                        /* GroupClause is equivalent to SortClause */
                        retval = _equalSortClause(a, b);
                        break;
+               case T_RowMarkClause:
+                       retval = _equalRowMarkClause(a, b);
+                       break;
                case T_FkConstraint:
                        retval = _equalFkConstraint(a, b);
                        break;