Logo Search packages:      
Sourcecode: postgresql-8.4 version File versions

equalfuncs.c

/*-------------------------------------------------------------------------
 *
 * equalfuncs.c
 *      Equality functions to compare node trees.
 *
 * NOTE: we currently support comparing all node types found in parse
 * trees.  We do not support comparing executor state trees; there
 * is no need for that, and no point in maintaining all the code that
 * would be needed.  We also do not support comparing Path trees, mainly
 * because the circular linkages between RelOptInfo and Path nodes can't
 * be handled easily in a simple depth-first traversal.
 *
 * Currently, in fact, equal() doesn't know how to compare Plan trees
 * either.  This might need to be fixed someday.
 *
 * NOTE: it is intentional that parse location fields (in nodes that have
 * one) are not compared.  This is because we want, for example, a variable
 * "x" to be considered equal() to another reference to "x" in the query.
 *
 *
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *      $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.355 2009/06/18 01:27:02 tgl Exp $
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include "nodes/relation.h"
#include "utils/datum.h"


/*
 * Macros to simplify comparison of different kinds of fields.    Use these
 * wherever possible to reduce the chance for silly typos.  Note that these
 * hard-wire the convention that the local variables in an Equal routine are
 * named 'a' and 'b'.
 */

/* Compare a simple scalar field (int, float, bool, enum, etc) */
#define COMPARE_SCALAR_FIELD(fldname) \
      do { \
            if (a->fldname != b->fldname) \
                  return false; \
      } while (0)

/* Compare a field that is a pointer to some kind of Node or Node tree */
#define COMPARE_NODE_FIELD(fldname) \
      do { \
            if (!equal(a->fldname, b->fldname)) \
                  return false; \
      } while (0)

/* Compare a field that is a pointer to a Bitmapset */
#define COMPARE_BITMAPSET_FIELD(fldname) \
      do { \
            if (!bms_equal(a->fldname, b->fldname)) \
                  return false; \
      } while (0)

/* Compare a field that is a pointer to a C string, or perhaps NULL */
#define COMPARE_STRING_FIELD(fldname) \
      do { \
            if (!equalstr(a->fldname, b->fldname)) \
                  return false; \
      } while (0)

/* Macro for comparing string fields that might be NULL */
#define equalstr(a, b)  \
      (((a) != NULL && (b) != NULL) ? (strcmp(a, b) == 0) : (a) == (b))

/* Compare a field that is a pointer to a simple palloc'd object of size sz */
#define COMPARE_POINTER_FIELD(fldname, sz) \
      do { \
            if (memcmp(a->fldname, b->fldname, (sz)) != 0) \
                  return false; \
      } while (0)

/* Compare a parse location field (this is a no-op, per note above) */
#define COMPARE_LOCATION_FIELD(fldname) \
      ((void) 0)


/*
 *    Stuff from primnodes.h
 */

static bool
_equalAlias(Alias *a, Alias *b)
{
      COMPARE_STRING_FIELD(aliasname);
      COMPARE_NODE_FIELD(colnames);

      return true;
}

static bool
_equalRangeVar(RangeVar *a, RangeVar *b)
{
      COMPARE_STRING_FIELD(catalogname);
      COMPARE_STRING_FIELD(schemaname);
      COMPARE_STRING_FIELD(relname);
      COMPARE_SCALAR_FIELD(inhOpt);
      COMPARE_SCALAR_FIELD(istemp);
      COMPARE_NODE_FIELD(alias);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalIntoClause(IntoClause *a, IntoClause *b)
{
      COMPARE_NODE_FIELD(rel);
      COMPARE_NODE_FIELD(colNames);
      COMPARE_NODE_FIELD(options);
      COMPARE_SCALAR_FIELD(onCommit);
      COMPARE_STRING_FIELD(tableSpaceName);

      return true;
}

/*
 * We don't need an _equalExpr because Expr is an abstract supertype which
 * should never actually get instantiated.      Also, since it has no common
 * fields except NodeTag, there's no need for a helper routine to factor
 * out comparing the common fields...
 */

static bool
_equalVar(Var *a, Var *b)
{
      COMPARE_SCALAR_FIELD(varno);
      COMPARE_SCALAR_FIELD(varattno);
      COMPARE_SCALAR_FIELD(vartype);
      COMPARE_SCALAR_FIELD(vartypmod);
      COMPARE_SCALAR_FIELD(varlevelsup);
      COMPARE_SCALAR_FIELD(varnoold);
      COMPARE_SCALAR_FIELD(varoattno);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalConst(Const *a, Const *b)
{
      COMPARE_SCALAR_FIELD(consttype);
      COMPARE_SCALAR_FIELD(consttypmod);
      COMPARE_SCALAR_FIELD(constlen);
      COMPARE_SCALAR_FIELD(constisnull);
      COMPARE_SCALAR_FIELD(constbyval);
      COMPARE_LOCATION_FIELD(location);

      /*
       * We treat all NULL constants of the same type as equal. Someday this
       * might need to change?  But datumIsEqual doesn't work on nulls, so...
       */
      if (a->constisnull)
            return true;
      return datumIsEqual(a->constvalue, b->constvalue,
                                    a->constbyval, a->constlen);
}

static bool
_equalParam(Param *a, Param *b)
{
      COMPARE_SCALAR_FIELD(paramkind);
      COMPARE_SCALAR_FIELD(paramid);
      COMPARE_SCALAR_FIELD(paramtype);
      COMPARE_SCALAR_FIELD(paramtypmod);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalAggref(Aggref *a, Aggref *b)
{
      COMPARE_SCALAR_FIELD(aggfnoid);
      COMPARE_SCALAR_FIELD(aggtype);
      COMPARE_NODE_FIELD(args);
      COMPARE_SCALAR_FIELD(agglevelsup);
      COMPARE_SCALAR_FIELD(aggstar);
      COMPARE_SCALAR_FIELD(aggdistinct);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalWindowFunc(WindowFunc *a, WindowFunc *b)
{
      COMPARE_SCALAR_FIELD(winfnoid);
      COMPARE_SCALAR_FIELD(wintype);
      COMPARE_NODE_FIELD(args);
      COMPARE_SCALAR_FIELD(winref);
      COMPARE_SCALAR_FIELD(winstar);
      COMPARE_SCALAR_FIELD(winagg);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalArrayRef(ArrayRef *a, ArrayRef *b)
{
      COMPARE_SCALAR_FIELD(refarraytype);
      COMPARE_SCALAR_FIELD(refelemtype);
      COMPARE_SCALAR_FIELD(reftypmod);
      COMPARE_NODE_FIELD(refupperindexpr);
      COMPARE_NODE_FIELD(reflowerindexpr);
      COMPARE_NODE_FIELD(refexpr);
      COMPARE_NODE_FIELD(refassgnexpr);

      return true;
}

static bool
_equalFuncExpr(FuncExpr *a, FuncExpr *b)
{
      COMPARE_SCALAR_FIELD(funcid);
      COMPARE_SCALAR_FIELD(funcresulttype);
      COMPARE_SCALAR_FIELD(funcretset);

      /*
       * Special-case COERCE_DONTCARE, so that planner can build coercion nodes
       * that are equal() to both explicit and implicit coercions.
       */
      if (a->funcformat != b->funcformat &&
            a->funcformat != COERCE_DONTCARE &&
            b->funcformat != COERCE_DONTCARE)
            return false;

      COMPARE_NODE_FIELD(args);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalOpExpr(OpExpr *a, OpExpr *b)
{
      COMPARE_SCALAR_FIELD(opno);

      /*
       * Special-case opfuncid: it is allowable for it to differ if one node
       * contains zero and the other doesn't.  This just means that the one node
       * isn't as far along in the parse/plan pipeline and hasn't had the
       * opfuncid cache filled yet.
       */
      if (a->opfuncid != b->opfuncid &&
            a->opfuncid != 0 &&
            b->opfuncid != 0)
            return false;

      COMPARE_SCALAR_FIELD(opresulttype);
      COMPARE_SCALAR_FIELD(opretset);
      COMPARE_NODE_FIELD(args);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalDistinctExpr(DistinctExpr *a, DistinctExpr *b)
{
      COMPARE_SCALAR_FIELD(opno);

      /*
       * Special-case opfuncid: it is allowable for it to differ if one node
       * contains zero and the other doesn't.  This just means that the one node
       * isn't as far along in the parse/plan pipeline and hasn't had the
       * opfuncid cache filled yet.
       */
      if (a->opfuncid != b->opfuncid &&
            a->opfuncid != 0 &&
            b->opfuncid != 0)
            return false;

      COMPARE_SCALAR_FIELD(opresulttype);
      COMPARE_SCALAR_FIELD(opretset);
      COMPARE_NODE_FIELD(args);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalScalarArrayOpExpr(ScalarArrayOpExpr *a, ScalarArrayOpExpr *b)
{
      COMPARE_SCALAR_FIELD(opno);

      /*
       * Special-case opfuncid: it is allowable for it to differ if one node
       * contains zero and the other doesn't.  This just means that the one node
       * isn't as far along in the parse/plan pipeline and hasn't had the
       * opfuncid cache filled yet.
       */
      if (a->opfuncid != b->opfuncid &&
            a->opfuncid != 0 &&
            b->opfuncid != 0)
            return false;

      COMPARE_SCALAR_FIELD(useOr);
      COMPARE_NODE_FIELD(args);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalBoolExpr(BoolExpr *a, BoolExpr *b)
{
      COMPARE_SCALAR_FIELD(boolop);
      COMPARE_NODE_FIELD(args);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalSubLink(SubLink *a, SubLink *b)
{
      COMPARE_SCALAR_FIELD(subLinkType);
      COMPARE_NODE_FIELD(testexpr);
      COMPARE_NODE_FIELD(operName);
      COMPARE_NODE_FIELD(subselect);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalSubPlan(SubPlan *a, SubPlan *b)
{
      COMPARE_SCALAR_FIELD(subLinkType);
      COMPARE_NODE_FIELD(testexpr);
      COMPARE_NODE_FIELD(paramIds);
      COMPARE_SCALAR_FIELD(plan_id);
      COMPARE_STRING_FIELD(plan_name);
      COMPARE_SCALAR_FIELD(firstColType);
      COMPARE_SCALAR_FIELD(firstColTypmod);
      COMPARE_SCALAR_FIELD(useHashTable);
      COMPARE_SCALAR_FIELD(unknownEqFalse);
      COMPARE_NODE_FIELD(setParam);
      COMPARE_NODE_FIELD(parParam);
      COMPARE_NODE_FIELD(args);
      COMPARE_SCALAR_FIELD(startup_cost);
      COMPARE_SCALAR_FIELD(per_call_cost);

      return true;
}

static bool
_equalAlternativeSubPlan(AlternativeSubPlan *a, AlternativeSubPlan *b)
{
      COMPARE_NODE_FIELD(subplans);

      return true;
}

static bool
_equalFieldSelect(FieldSelect *a, FieldSelect *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_SCALAR_FIELD(fieldnum);
      COMPARE_SCALAR_FIELD(resulttype);
      COMPARE_SCALAR_FIELD(resulttypmod);

      return true;
}

static bool
_equalFieldStore(FieldStore *a, FieldStore *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_NODE_FIELD(newvals);
      COMPARE_NODE_FIELD(fieldnums);
      COMPARE_SCALAR_FIELD(resulttype);

      return true;
}

static bool
_equalRelabelType(RelabelType *a, RelabelType *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_SCALAR_FIELD(resulttype);
      COMPARE_SCALAR_FIELD(resulttypmod);

      /*
       * Special-case COERCE_DONTCARE, so that planner can build coercion nodes
       * that are equal() to both explicit and implicit coercions.
       */
      if (a->relabelformat != b->relabelformat &&
            a->relabelformat != COERCE_DONTCARE &&
            b->relabelformat != COERCE_DONTCARE)
            return false;

      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalCoerceViaIO(CoerceViaIO *a, CoerceViaIO *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_SCALAR_FIELD(resulttype);

      /*
       * Special-case COERCE_DONTCARE, so that planner can build coercion nodes
       * that are equal() to both explicit and implicit coercions.
       */
      if (a->coerceformat != b->coerceformat &&
            a->coerceformat != COERCE_DONTCARE &&
            b->coerceformat != COERCE_DONTCARE)
            return false;

      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalArrayCoerceExpr(ArrayCoerceExpr *a, ArrayCoerceExpr *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_SCALAR_FIELD(elemfuncid);
      COMPARE_SCALAR_FIELD(resulttype);
      COMPARE_SCALAR_FIELD(resulttypmod);
      COMPARE_SCALAR_FIELD(isExplicit);

      /*
       * Special-case COERCE_DONTCARE, so that planner can build coercion nodes
       * that are equal() to both explicit and implicit coercions.
       */
      if (a->coerceformat != b->coerceformat &&
            a->coerceformat != COERCE_DONTCARE &&
            b->coerceformat != COERCE_DONTCARE)
            return false;

      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalConvertRowtypeExpr(ConvertRowtypeExpr *a, ConvertRowtypeExpr *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_SCALAR_FIELD(resulttype);

      /*
       * Special-case COERCE_DONTCARE, so that planner can build coercion nodes
       * that are equal() to both explicit and implicit coercions.
       */
      if (a->convertformat != b->convertformat &&
            a->convertformat != COERCE_DONTCARE &&
            b->convertformat != COERCE_DONTCARE)
            return false;

      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalCaseExpr(CaseExpr *a, CaseExpr *b)
{
      COMPARE_SCALAR_FIELD(casetype);
      COMPARE_NODE_FIELD(arg);
      COMPARE_NODE_FIELD(args);
      COMPARE_NODE_FIELD(defresult);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalCaseWhen(CaseWhen *a, CaseWhen *b)
{
      COMPARE_NODE_FIELD(expr);
      COMPARE_NODE_FIELD(result);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalCaseTestExpr(CaseTestExpr *a, CaseTestExpr *b)
{
      COMPARE_SCALAR_FIELD(typeId);
      COMPARE_SCALAR_FIELD(typeMod);

      return true;
}

static bool
_equalArrayExpr(ArrayExpr *a, ArrayExpr *b)
{
      COMPARE_SCALAR_FIELD(array_typeid);
      COMPARE_SCALAR_FIELD(element_typeid);
      COMPARE_NODE_FIELD(elements);
      COMPARE_SCALAR_FIELD(multidims);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalRowExpr(RowExpr *a, RowExpr *b)
{
      COMPARE_NODE_FIELD(args);
      COMPARE_SCALAR_FIELD(row_typeid);

      /*
       * Special-case COERCE_DONTCARE, so that planner can build coercion nodes
       * that are equal() to both explicit and implicit coercions.
       */
      if (a->row_format != b->row_format &&
            a->row_format != COERCE_DONTCARE &&
            b->row_format != COERCE_DONTCARE)
            return false;

      COMPARE_NODE_FIELD(colnames);
      COMPARE_LOCATION_FIELD(location);

      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)
{
      COMPARE_SCALAR_FIELD(coalescetype);
      COMPARE_NODE_FIELD(args);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalMinMaxExpr(MinMaxExpr *a, MinMaxExpr *b)
{
      COMPARE_SCALAR_FIELD(minmaxtype);
      COMPARE_SCALAR_FIELD(op);
      COMPARE_NODE_FIELD(args);
      COMPARE_LOCATION_FIELD(location);

      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);
      COMPARE_SCALAR_FIELD(xmloption);
      COMPARE_SCALAR_FIELD(type);
      COMPARE_SCALAR_FIELD(typmod);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalNullIfExpr(NullIfExpr *a, NullIfExpr *b)
{
      COMPARE_SCALAR_FIELD(opno);

      /*
       * Special-case opfuncid: it is allowable for it to differ if one node
       * contains zero and the other doesn't.  This just means that the one node
       * isn't as far along in the parse/plan pipeline and hasn't had the
       * opfuncid cache filled yet.
       */
      if (a->opfuncid != b->opfuncid &&
            a->opfuncid != 0 &&
            b->opfuncid != 0)
            return false;

      COMPARE_SCALAR_FIELD(opresulttype);
      COMPARE_SCALAR_FIELD(opretset);
      COMPARE_NODE_FIELD(args);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalNullTest(NullTest *a, NullTest *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_SCALAR_FIELD(nulltesttype);

      return true;
}

static bool
_equalBooleanTest(BooleanTest *a, BooleanTest *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_SCALAR_FIELD(booltesttype);

      return true;
}

static bool
_equalCoerceToDomain(CoerceToDomain *a, CoerceToDomain *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_SCALAR_FIELD(resulttype);
      COMPARE_SCALAR_FIELD(resulttypmod);

      /*
       * Special-case COERCE_DONTCARE, so that planner can build coercion nodes
       * that are equal() to both explicit and implicit coercions.
       */
      if (a->coercionformat != b->coercionformat &&
            a->coercionformat != COERCE_DONTCARE &&
            b->coercionformat != COERCE_DONTCARE)
            return false;

      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalCoerceToDomainValue(CoerceToDomainValue *a, CoerceToDomainValue *b)
{
      COMPARE_SCALAR_FIELD(typeId);
      COMPARE_SCALAR_FIELD(typeMod);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalSetToDefault(SetToDefault *a, SetToDefault *b)
{
      COMPARE_SCALAR_FIELD(typeId);
      COMPARE_SCALAR_FIELD(typeMod);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalCurrentOfExpr(CurrentOfExpr *a, CurrentOfExpr *b)
{
      COMPARE_SCALAR_FIELD(cvarno);
      COMPARE_STRING_FIELD(cursor_name);
      COMPARE_SCALAR_FIELD(cursor_param);

      return true;
}

static bool
_equalTargetEntry(TargetEntry *a, TargetEntry *b)
{
      COMPARE_NODE_FIELD(expr);
      COMPARE_SCALAR_FIELD(resno);
      COMPARE_STRING_FIELD(resname);
      COMPARE_SCALAR_FIELD(ressortgroupref);
      COMPARE_SCALAR_FIELD(resorigtbl);
      COMPARE_SCALAR_FIELD(resorigcol);
      COMPARE_SCALAR_FIELD(resjunk);

      return true;
}

static bool
_equalRangeTblRef(RangeTblRef *a, RangeTblRef *b)
{
      COMPARE_SCALAR_FIELD(rtindex);

      return true;
}

static bool
_equalJoinExpr(JoinExpr *a, JoinExpr *b)
{
      COMPARE_SCALAR_FIELD(jointype);
      COMPARE_SCALAR_FIELD(isNatural);
      COMPARE_NODE_FIELD(larg);
      COMPARE_NODE_FIELD(rarg);
      COMPARE_NODE_FIELD(using);
      COMPARE_NODE_FIELD(quals);
      COMPARE_NODE_FIELD(alias);
      COMPARE_SCALAR_FIELD(rtindex);

      return true;
}

static bool
_equalFromExpr(FromExpr *a, FromExpr *b)
{
      COMPARE_NODE_FIELD(fromlist);
      COMPARE_NODE_FIELD(quals);

      return true;
}


/*
 * Stuff from relation.h
 */

static bool
_equalPathKey(PathKey *a, PathKey *b)
{
      /*
       * This is normally used on non-canonicalized PathKeys, so must chase up
       * to the topmost merged EquivalenceClass and see if those are the same
       * (by pointer equality).
       */
      EquivalenceClass *a_eclass;
      EquivalenceClass *b_eclass;

      a_eclass = a->pk_eclass;
      while (a_eclass->ec_merged)
            a_eclass = a_eclass->ec_merged;
      b_eclass = b->pk_eclass;
      while (b_eclass->ec_merged)
            b_eclass = b_eclass->ec_merged;
      if (a_eclass != b_eclass)
            return false;
      COMPARE_SCALAR_FIELD(pk_opfamily);
      COMPARE_SCALAR_FIELD(pk_strategy);
      COMPARE_SCALAR_FIELD(pk_nulls_first);

      return true;
}

static bool
_equalRestrictInfo(RestrictInfo *a, RestrictInfo *b)
{
      COMPARE_NODE_FIELD(clause);
      COMPARE_SCALAR_FIELD(is_pushed_down);
      COMPARE_SCALAR_FIELD(outerjoin_delayed);
      COMPARE_BITMAPSET_FIELD(required_relids);
      COMPARE_BITMAPSET_FIELD(nullable_relids);

      /*
       * We ignore all the remaining fields, since they may not be set yet, and
       * should be derivable from the clause anyway.
       */

      return true;
}

static bool
_equalPlaceHolderVar(PlaceHolderVar *a, PlaceHolderVar *b)
{
      /*
       * We intentionally do not compare phexpr.      Two PlaceHolderVars with the
       * same ID and levelsup should be considered equal even if the contained
       * expressions have managed to mutate to different states.  One way in
       * which that can happen is that initplan sublinks would get replaced by
       * differently-numbered Params when sublink folding is done.  (The end
       * result of such a situation would be some unreferenced initplans, which
       * is annoying but not really a problem.)
       *
       * COMPARE_NODE_FIELD(phexpr);
       */
      COMPARE_BITMAPSET_FIELD(phrels);
      COMPARE_SCALAR_FIELD(phid);
      COMPARE_SCALAR_FIELD(phlevelsup);

      return true;
}

static bool
_equalSpecialJoinInfo(SpecialJoinInfo *a, SpecialJoinInfo *b)
{
      COMPARE_BITMAPSET_FIELD(min_lefthand);
      COMPARE_BITMAPSET_FIELD(min_righthand);
      COMPARE_BITMAPSET_FIELD(syn_lefthand);
      COMPARE_BITMAPSET_FIELD(syn_righthand);
      COMPARE_SCALAR_FIELD(jointype);
      COMPARE_SCALAR_FIELD(lhs_strict);
      COMPARE_SCALAR_FIELD(delay_upper_joins);
      COMPARE_NODE_FIELD(join_quals);

      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(translated_vars);
      COMPARE_SCALAR_FIELD(parent_reloid);

      return true;
}

static bool
_equalPlaceHolderInfo(PlaceHolderInfo *a, PlaceHolderInfo *b)
{
      COMPARE_SCALAR_FIELD(phid);
      COMPARE_NODE_FIELD(ph_var);
      COMPARE_BITMAPSET_FIELD(ph_eval_at);
      COMPARE_BITMAPSET_FIELD(ph_needed);
      COMPARE_SCALAR_FIELD(ph_width);

      return true;
}


/*
 * Stuff from parsenodes.h
 */

static bool
_equalQuery(Query *a, Query *b)
{
      COMPARE_SCALAR_FIELD(commandType);
      COMPARE_SCALAR_FIELD(querySource);
      COMPARE_SCALAR_FIELD(canSetTag);
      COMPARE_NODE_FIELD(utilityStmt);
      COMPARE_SCALAR_FIELD(resultRelation);
      COMPARE_NODE_FIELD(intoClause);
      COMPARE_SCALAR_FIELD(hasAggs);
      COMPARE_SCALAR_FIELD(hasWindowFuncs);
      COMPARE_SCALAR_FIELD(hasSubLinks);
      COMPARE_SCALAR_FIELD(hasDistinctOn);
      COMPARE_SCALAR_FIELD(hasRecursive);
      COMPARE_NODE_FIELD(cteList);
      COMPARE_NODE_FIELD(rtable);
      COMPARE_NODE_FIELD(jointree);
      COMPARE_NODE_FIELD(targetList);
      COMPARE_NODE_FIELD(returningList);
      COMPARE_NODE_FIELD(groupClause);
      COMPARE_NODE_FIELD(havingQual);
      COMPARE_NODE_FIELD(windowClause);
      COMPARE_NODE_FIELD(distinctClause);
      COMPARE_NODE_FIELD(sortClause);
      COMPARE_NODE_FIELD(limitOffset);
      COMPARE_NODE_FIELD(limitCount);
      COMPARE_NODE_FIELD(rowMarks);
      COMPARE_NODE_FIELD(setOperations);

      return true;
}

static bool
_equalInsertStmt(InsertStmt *a, InsertStmt *b)
{
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(cols);
      COMPARE_NODE_FIELD(selectStmt);
      COMPARE_NODE_FIELD(returningList);

      return true;
}

static bool
_equalDeleteStmt(DeleteStmt *a, DeleteStmt *b)
{
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(usingClause);
      COMPARE_NODE_FIELD(whereClause);
      COMPARE_NODE_FIELD(returningList);

      return true;
}

static bool
_equalUpdateStmt(UpdateStmt *a, UpdateStmt *b)
{
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(targetList);
      COMPARE_NODE_FIELD(whereClause);
      COMPARE_NODE_FIELD(fromClause);
      COMPARE_NODE_FIELD(returningList);

      return true;
}

static bool
_equalSelectStmt(SelectStmt *a, SelectStmt *b)
{
      COMPARE_NODE_FIELD(distinctClause);
      COMPARE_NODE_FIELD(intoClause);
      COMPARE_NODE_FIELD(targetList);
      COMPARE_NODE_FIELD(fromClause);
      COMPARE_NODE_FIELD(whereClause);
      COMPARE_NODE_FIELD(groupClause);
      COMPARE_NODE_FIELD(havingClause);
      COMPARE_NODE_FIELD(windowClause);
      COMPARE_NODE_FIELD(withClause);
      COMPARE_NODE_FIELD(valuesLists);
      COMPARE_NODE_FIELD(sortClause);
      COMPARE_NODE_FIELD(limitOffset);
      COMPARE_NODE_FIELD(limitCount);
      COMPARE_NODE_FIELD(lockingClause);
      COMPARE_SCALAR_FIELD(op);
      COMPARE_SCALAR_FIELD(all);
      COMPARE_NODE_FIELD(larg);
      COMPARE_NODE_FIELD(rarg);

      return true;
}

static bool
_equalSetOperationStmt(SetOperationStmt *a, SetOperationStmt *b)
{
      COMPARE_SCALAR_FIELD(op);
      COMPARE_SCALAR_FIELD(all);
      COMPARE_NODE_FIELD(larg);
      COMPARE_NODE_FIELD(rarg);
      COMPARE_NODE_FIELD(colTypes);
      COMPARE_NODE_FIELD(colTypmods);
      COMPARE_NODE_FIELD(groupClauses);

      return true;
}

static bool
_equalAlterTableStmt(AlterTableStmt *a, AlterTableStmt *b)
{
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(cmds);
      COMPARE_SCALAR_FIELD(relkind);

      return true;
}

static bool
_equalAlterTableCmd(AlterTableCmd *a, AlterTableCmd *b)
{
      COMPARE_SCALAR_FIELD(subtype);
      COMPARE_STRING_FIELD(name);
      COMPARE_NODE_FIELD(def);
      COMPARE_NODE_FIELD(transform);
      COMPARE_SCALAR_FIELD(behavior);

      return true;
}

static bool
_equalAlterDomainStmt(AlterDomainStmt *a, AlterDomainStmt *b)
{
      COMPARE_SCALAR_FIELD(subtype);
      COMPARE_NODE_FIELD(typename);
      COMPARE_STRING_FIELD(name);
      COMPARE_NODE_FIELD(def);
      COMPARE_SCALAR_FIELD(behavior);

      return true;
}

static bool
_equalGrantStmt(GrantStmt *a, GrantStmt *b)
{
      COMPARE_SCALAR_FIELD(is_grant);
      COMPARE_SCALAR_FIELD(objtype);
      COMPARE_NODE_FIELD(objects);
      COMPARE_NODE_FIELD(privileges);
      COMPARE_NODE_FIELD(grantees);
      COMPARE_SCALAR_FIELD(grant_option);
      COMPARE_SCALAR_FIELD(behavior);

      return true;
}

static bool
_equalPrivGrantee(PrivGrantee *a, PrivGrantee *b)
{
      COMPARE_STRING_FIELD(rolname);

      return true;
}

static bool
_equalFuncWithArgs(FuncWithArgs *a, FuncWithArgs *b)
{
      COMPARE_NODE_FIELD(funcname);
      COMPARE_NODE_FIELD(funcargs);

      return true;
}

static bool
_equalAccessPriv(AccessPriv *a, AccessPriv *b)
{
      COMPARE_STRING_FIELD(priv_name);
      COMPARE_NODE_FIELD(cols);

      return true;
}

static bool
_equalGrantRoleStmt(GrantRoleStmt *a, GrantRoleStmt *b)
{
      COMPARE_NODE_FIELD(granted_roles);
      COMPARE_NODE_FIELD(grantee_roles);
      COMPARE_SCALAR_FIELD(is_grant);
      COMPARE_SCALAR_FIELD(admin_opt);
      COMPARE_STRING_FIELD(grantor);
      COMPARE_SCALAR_FIELD(behavior);

      return true;
}

static bool
_equalDeclareCursorStmt(DeclareCursorStmt *a, DeclareCursorStmt *b)
{
      COMPARE_STRING_FIELD(portalname);
      COMPARE_SCALAR_FIELD(options);
      COMPARE_NODE_FIELD(query);

      return true;
}

static bool
_equalClosePortalStmt(ClosePortalStmt *a, ClosePortalStmt *b)
{
      COMPARE_STRING_FIELD(portalname);

      return true;
}

static bool
_equalClusterStmt(ClusterStmt *a, ClusterStmt *b)
{
      COMPARE_NODE_FIELD(relation);
      COMPARE_STRING_FIELD(indexname);
      COMPARE_SCALAR_FIELD(verbose);

      return true;
}

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);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalCreateStmt(CreateStmt *a, CreateStmt *b)
{
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(tableElts);
      COMPARE_NODE_FIELD(inhRelations);
      COMPARE_NODE_FIELD(constraints);
      COMPARE_NODE_FIELD(options);
      COMPARE_SCALAR_FIELD(oncommit);
      COMPARE_STRING_FIELD(tablespacename);

      return true;
}

static bool
_equalInhRelation(InhRelation *a, InhRelation *b)
{
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(options);

      return true;
}

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;
}

static bool
_equalDropStmt(DropStmt *a, DropStmt *b)
{
      COMPARE_NODE_FIELD(objects);
      COMPARE_SCALAR_FIELD(removeType);
      COMPARE_SCALAR_FIELD(behavior);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalTruncateStmt(TruncateStmt *a, TruncateStmt *b)
{
      COMPARE_NODE_FIELD(relations);
      COMPARE_SCALAR_FIELD(restart_seqs);
      COMPARE_SCALAR_FIELD(behavior);

      return true;
}

static bool
_equalCommentStmt(CommentStmt *a, CommentStmt *b)
{
      COMPARE_SCALAR_FIELD(objtype);
      COMPARE_NODE_FIELD(objname);
      COMPARE_NODE_FIELD(objargs);
      COMPARE_STRING_FIELD(comment);

      return true;
}

static bool
_equalFetchStmt(FetchStmt *a, FetchStmt *b)
{
      COMPARE_SCALAR_FIELD(direction);
      COMPARE_SCALAR_FIELD(howMany);
      COMPARE_STRING_FIELD(portalname);
      COMPARE_SCALAR_FIELD(ismove);

      return true;
}

static bool
_equalIndexStmt(IndexStmt *a, IndexStmt *b)
{
      COMPARE_STRING_FIELD(idxname);
      COMPARE_NODE_FIELD(relation);
      COMPARE_STRING_FIELD(accessMethod);
      COMPARE_STRING_FIELD(tableSpace);
      COMPARE_NODE_FIELD(indexParams);
      COMPARE_NODE_FIELD(options);
      COMPARE_NODE_FIELD(whereClause);
      COMPARE_SCALAR_FIELD(unique);
      COMPARE_SCALAR_FIELD(primary);
      COMPARE_SCALAR_FIELD(isconstraint);
      COMPARE_SCALAR_FIELD(concurrent);

      return true;
}

static bool
_equalCreateFunctionStmt(CreateFunctionStmt *a, CreateFunctionStmt *b)
{
      COMPARE_SCALAR_FIELD(replace);
      COMPARE_NODE_FIELD(funcname);
      COMPARE_NODE_FIELD(parameters);
      COMPARE_NODE_FIELD(returnType);
      COMPARE_NODE_FIELD(options);
      COMPARE_NODE_FIELD(withClause);

      return true;
}

static bool
_equalFunctionParameter(FunctionParameter *a, FunctionParameter *b)
{
      COMPARE_STRING_FIELD(name);
      COMPARE_NODE_FIELD(argType);
      COMPARE_SCALAR_FIELD(mode);
      COMPARE_NODE_FIELD(defexpr);

      return true;
}

static bool
_equalAlterFunctionStmt(AlterFunctionStmt *a, AlterFunctionStmt *b)
{
      COMPARE_NODE_FIELD(func);
      COMPARE_NODE_FIELD(actions);

      return true;
}

static bool
_equalRemoveFuncStmt(RemoveFuncStmt *a, RemoveFuncStmt *b)
{
      COMPARE_SCALAR_FIELD(kind);
      COMPARE_NODE_FIELD(name);
      COMPARE_NODE_FIELD(args);
      COMPARE_SCALAR_FIELD(behavior);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalRemoveOpClassStmt(RemoveOpClassStmt *a, RemoveOpClassStmt *b)
{
      COMPARE_NODE_FIELD(opclassname);
      COMPARE_STRING_FIELD(amname);
      COMPARE_SCALAR_FIELD(behavior);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalRemoveOpFamilyStmt(RemoveOpFamilyStmt *a, RemoveOpFamilyStmt *b)
{
      COMPARE_NODE_FIELD(opfamilyname);
      COMPARE_STRING_FIELD(amname);
      COMPARE_SCALAR_FIELD(behavior);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalRenameStmt(RenameStmt *a, RenameStmt *b)
{
      COMPARE_SCALAR_FIELD(renameType);
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(object);
      COMPARE_NODE_FIELD(objarg);
      COMPARE_STRING_FIELD(subname);
      COMPARE_STRING_FIELD(newname);

      return true;
}

static bool
_equalAlterObjectSchemaStmt(AlterObjectSchemaStmt *a, AlterObjectSchemaStmt *b)
{
      COMPARE_SCALAR_FIELD(objectType);
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(object);
      COMPARE_NODE_FIELD(objarg);
      COMPARE_STRING_FIELD(addname);
      COMPARE_STRING_FIELD(newschema);

      return true;
}

static bool
_equalAlterOwnerStmt(AlterOwnerStmt *a, AlterOwnerStmt *b)
{
      COMPARE_SCALAR_FIELD(objectType);
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(object);
      COMPARE_NODE_FIELD(objarg);
      COMPARE_STRING_FIELD(addname);
      COMPARE_STRING_FIELD(newowner);

      return true;
}

static bool
_equalRuleStmt(RuleStmt *a, RuleStmt *b)
{
      COMPARE_NODE_FIELD(relation);
      COMPARE_STRING_FIELD(rulename);
      COMPARE_NODE_FIELD(whereClause);
      COMPARE_SCALAR_FIELD(event);
      COMPARE_SCALAR_FIELD(instead);
      COMPARE_NODE_FIELD(actions);
      COMPARE_SCALAR_FIELD(replace);

      return true;
}

static bool
_equalNotifyStmt(NotifyStmt *a, NotifyStmt *b)
{
      COMPARE_STRING_FIELD(conditionname);

      return true;
}

static bool
_equalListenStmt(ListenStmt *a, ListenStmt *b)
{
      COMPARE_STRING_FIELD(conditionname);

      return true;
}

static bool
_equalUnlistenStmt(UnlistenStmt *a, UnlistenStmt *b)
{
      COMPARE_STRING_FIELD(conditionname);

      return true;
}

static bool
_equalTransactionStmt(TransactionStmt *a, TransactionStmt *b)
{
      COMPARE_SCALAR_FIELD(kind);
      COMPARE_NODE_FIELD(options);
      COMPARE_STRING_FIELD(gid);

      return true;
}

static bool
_equalCompositeTypeStmt(CompositeTypeStmt *a, CompositeTypeStmt *b)
{
      COMPARE_NODE_FIELD(typevar);
      COMPARE_NODE_FIELD(coldeflist);

      return true;
}

static bool
_equalCreateEnumStmt(CreateEnumStmt *a, CreateEnumStmt *b)
{
      COMPARE_NODE_FIELD(typename);
      COMPARE_NODE_FIELD(vals);

      return true;
}

static bool
_equalViewStmt(ViewStmt *a, ViewStmt *b)
{
      COMPARE_NODE_FIELD(view);
      COMPARE_NODE_FIELD(aliases);
      COMPARE_NODE_FIELD(query);
      COMPARE_SCALAR_FIELD(replace);

      return true;
}

static bool
_equalLoadStmt(LoadStmt *a, LoadStmt *b)
{
      COMPARE_STRING_FIELD(filename);

      return true;
}

static bool
_equalCreateDomainStmt(CreateDomainStmt *a, CreateDomainStmt *b)
{
      COMPARE_NODE_FIELD(domainname);
      COMPARE_NODE_FIELD(typename);
      COMPARE_NODE_FIELD(constraints);

      return true;
}

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);
      COMPARE_SCALAR_FIELD(isDefault);

      return true;
}

static bool
_equalCreateOpClassItem(CreateOpClassItem *a, CreateOpClassItem *b)
{
      COMPARE_SCALAR_FIELD(itemtype);
      COMPARE_NODE_FIELD(name);
      COMPARE_NODE_FIELD(args);
      COMPARE_SCALAR_FIELD(number);
      COMPARE_NODE_FIELD(class_args);
      COMPARE_NODE_FIELD(storedtype);

      return true;
}

static bool
_equalCreateOpFamilyStmt(CreateOpFamilyStmt *a, CreateOpFamilyStmt *b)
{
      COMPARE_NODE_FIELD(opfamilyname);
      COMPARE_STRING_FIELD(amname);

      return true;
}

static bool
_equalAlterOpFamilyStmt(AlterOpFamilyStmt *a, AlterOpFamilyStmt *b)
{
      COMPARE_NODE_FIELD(opfamilyname);
      COMPARE_STRING_FIELD(amname);
      COMPARE_SCALAR_FIELD(isDrop);
      COMPARE_NODE_FIELD(items);

      return true;
}

static bool
_equalCreatedbStmt(CreatedbStmt *a, CreatedbStmt *b)
{
      COMPARE_STRING_FIELD(dbname);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalAlterDatabaseStmt(AlterDatabaseStmt *a, AlterDatabaseStmt *b)
{
      COMPARE_STRING_FIELD(dbname);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalAlterDatabaseSetStmt(AlterDatabaseSetStmt *a, AlterDatabaseSetStmt *b)
{
      COMPARE_STRING_FIELD(dbname);
      COMPARE_NODE_FIELD(setstmt);

      return true;
}

static bool
_equalDropdbStmt(DropdbStmt *a, DropdbStmt *b)
{
      COMPARE_STRING_FIELD(dbname);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalVacuumStmt(VacuumStmt *a, VacuumStmt *b)
{
      COMPARE_SCALAR_FIELD(vacuum);
      COMPARE_SCALAR_FIELD(full);
      COMPARE_SCALAR_FIELD(analyze);
      COMPARE_SCALAR_FIELD(verbose);
      COMPARE_SCALAR_FIELD(freeze_min_age);
      COMPARE_SCALAR_FIELD(freeze_table_age);
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(va_cols);

      return true;
}

static bool
_equalExplainStmt(ExplainStmt *a, ExplainStmt *b)
{
      COMPARE_NODE_FIELD(query);
      COMPARE_SCALAR_FIELD(verbose);
      COMPARE_SCALAR_FIELD(analyze);

      return true;
}

static bool
_equalCreateSeqStmt(CreateSeqStmt *a, CreateSeqStmt *b)
{
      COMPARE_NODE_FIELD(sequence);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalAlterSeqStmt(AlterSeqStmt *a, AlterSeqStmt *b)
{
      COMPARE_NODE_FIELD(sequence);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalVariableSetStmt(VariableSetStmt *a, VariableSetStmt *b)
{
      COMPARE_SCALAR_FIELD(kind);
      COMPARE_STRING_FIELD(name);
      COMPARE_NODE_FIELD(args);
      COMPARE_SCALAR_FIELD(is_local);

      return true;
}

static bool
_equalVariableShowStmt(VariableShowStmt *a, VariableShowStmt *b)
{
      COMPARE_STRING_FIELD(name);

      return true;
}

static bool
_equalDiscardStmt(DiscardStmt *a, DiscardStmt *b)
{
      COMPARE_SCALAR_FIELD(target);

      return true;
}

static bool
_equalCreateTableSpaceStmt(CreateTableSpaceStmt *a, CreateTableSpaceStmt *b)
{
      COMPARE_STRING_FIELD(tablespacename);
      COMPARE_STRING_FIELD(owner);
      COMPARE_STRING_FIELD(location);

      return true;
}

static bool
_equalDropTableSpaceStmt(DropTableSpaceStmt *a, DropTableSpaceStmt *b)
{
      COMPARE_STRING_FIELD(tablespacename);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalCreateFdwStmt(CreateFdwStmt *a, CreateFdwStmt *b)
{
      COMPARE_STRING_FIELD(fdwname);
      COMPARE_NODE_FIELD(validator);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalAlterFdwStmt(AlterFdwStmt *a, AlterFdwStmt *b)
{
      COMPARE_STRING_FIELD(fdwname);
      COMPARE_NODE_FIELD(validator);
      COMPARE_SCALAR_FIELD(change_validator);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalDropFdwStmt(DropFdwStmt *a, DropFdwStmt *b)
{
      COMPARE_STRING_FIELD(fdwname);
      COMPARE_SCALAR_FIELD(missing_ok);
      COMPARE_SCALAR_FIELD(behavior);

      return true;
}

static bool
_equalCreateForeignServerStmt(CreateForeignServerStmt *a, CreateForeignServerStmt *b)
{
      COMPARE_STRING_FIELD(servername);
      COMPARE_STRING_FIELD(servertype);
      COMPARE_STRING_FIELD(version);
      COMPARE_STRING_FIELD(fdwname);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalAlterForeignServerStmt(AlterForeignServerStmt *a, AlterForeignServerStmt *b)
{
      COMPARE_STRING_FIELD(servername);
      COMPARE_STRING_FIELD(version);
      COMPARE_NODE_FIELD(options);
      COMPARE_SCALAR_FIELD(has_version);

      return true;
}

static bool
_equalDropForeignServerStmt(DropForeignServerStmt *a, DropForeignServerStmt *b)
{
      COMPARE_STRING_FIELD(servername);
      COMPARE_SCALAR_FIELD(missing_ok);
      COMPARE_SCALAR_FIELD(behavior);

      return true;
}

static bool
_equalCreateUserMappingStmt(CreateUserMappingStmt *a, CreateUserMappingStmt *b)
{
      COMPARE_STRING_FIELD(username);
      COMPARE_STRING_FIELD(servername);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalAlterUserMappingStmt(AlterUserMappingStmt *a, AlterUserMappingStmt *b)
{
      COMPARE_STRING_FIELD(username);
      COMPARE_STRING_FIELD(servername);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalDropUserMappingStmt(DropUserMappingStmt *a, DropUserMappingStmt *b)
{
      COMPARE_STRING_FIELD(username);
      COMPARE_STRING_FIELD(servername);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalCreateTrigStmt(CreateTrigStmt *a, CreateTrigStmt *b)
{
      COMPARE_STRING_FIELD(trigname);
      COMPARE_NODE_FIELD(relation);
      COMPARE_NODE_FIELD(funcname);
      COMPARE_NODE_FIELD(args);
      COMPARE_SCALAR_FIELD(before);
      COMPARE_SCALAR_FIELD(row);
      COMPARE_SCALAR_FIELD(events);
      COMPARE_SCALAR_FIELD(isconstraint);
      COMPARE_SCALAR_FIELD(deferrable);
      COMPARE_SCALAR_FIELD(initdeferred);
      COMPARE_NODE_FIELD(constrrel);

      return true;
}

static bool
_equalDropPropertyStmt(DropPropertyStmt *a, DropPropertyStmt *b)
{
      COMPARE_NODE_FIELD(relation);
      COMPARE_STRING_FIELD(property);
      COMPARE_SCALAR_FIELD(removeType);
      COMPARE_SCALAR_FIELD(behavior);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalCreatePLangStmt(CreatePLangStmt *a, CreatePLangStmt *b)
{
      COMPARE_STRING_FIELD(plname);
      COMPARE_NODE_FIELD(plhandler);
      COMPARE_NODE_FIELD(plvalidator);
      COMPARE_SCALAR_FIELD(pltrusted);

      return true;
}

static bool
_equalDropPLangStmt(DropPLangStmt *a, DropPLangStmt *b)
{
      COMPARE_STRING_FIELD(plname);
      COMPARE_SCALAR_FIELD(behavior);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalCreateRoleStmt(CreateRoleStmt *a, CreateRoleStmt *b)
{
      COMPARE_SCALAR_FIELD(stmt_type);
      COMPARE_STRING_FIELD(role);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalAlterRoleStmt(AlterRoleStmt *a, AlterRoleStmt *b)
{
      COMPARE_STRING_FIELD(role);
      COMPARE_NODE_FIELD(options);
      COMPARE_SCALAR_FIELD(action);

      return true;
}

static bool
_equalAlterRoleSetStmt(AlterRoleSetStmt *a, AlterRoleSetStmt *b)
{
      COMPARE_STRING_FIELD(role);
      COMPARE_NODE_FIELD(setstmt);

      return true;
}

static bool
_equalDropRoleStmt(DropRoleStmt *a, DropRoleStmt *b)
{
      COMPARE_NODE_FIELD(roles);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalLockStmt(LockStmt *a, LockStmt *b)
{
      COMPARE_NODE_FIELD(relations);
      COMPARE_SCALAR_FIELD(mode);
      COMPARE_SCALAR_FIELD(nowait);

      return true;
}

static bool
_equalConstraintsSetStmt(ConstraintsSetStmt *a, ConstraintsSetStmt *b)
{
      COMPARE_NODE_FIELD(constraints);
      COMPARE_SCALAR_FIELD(deferred);

      return true;
}

static bool
_equalReindexStmt(ReindexStmt *a, ReindexStmt *b)
{
      COMPARE_SCALAR_FIELD(kind);
      COMPARE_NODE_FIELD(relation);
      COMPARE_STRING_FIELD(name);
      COMPARE_SCALAR_FIELD(do_system);
      COMPARE_SCALAR_FIELD(do_user);

      return true;
}

static bool
_equalCreateSchemaStmt(CreateSchemaStmt *a, CreateSchemaStmt *b)
{
      COMPARE_STRING_FIELD(schemaname);
      COMPARE_STRING_FIELD(authid);
      COMPARE_NODE_FIELD(schemaElts);

      return true;
}

static bool
_equalCreateConversionStmt(CreateConversionStmt *a, CreateConversionStmt *b)
{
      COMPARE_NODE_FIELD(conversion_name);
      COMPARE_STRING_FIELD(for_encoding_name);
      COMPARE_STRING_FIELD(to_encoding_name);
      COMPARE_NODE_FIELD(func_name);
      COMPARE_SCALAR_FIELD(def);

      return true;
}

static bool
_equalCreateCastStmt(CreateCastStmt *a, CreateCastStmt *b)
{
      COMPARE_NODE_FIELD(sourcetype);
      COMPARE_NODE_FIELD(targettype);
      COMPARE_NODE_FIELD(func);
      COMPARE_SCALAR_FIELD(context);
      COMPARE_SCALAR_FIELD(inout);

      return true;
}

static bool
_equalDropCastStmt(DropCastStmt *a, DropCastStmt *b)
{
      COMPARE_NODE_FIELD(sourcetype);
      COMPARE_NODE_FIELD(targettype);
      COMPARE_SCALAR_FIELD(behavior);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalPrepareStmt(PrepareStmt *a, PrepareStmt *b)
{
      COMPARE_STRING_FIELD(name);
      COMPARE_NODE_FIELD(argtypes);
      COMPARE_NODE_FIELD(query);

      return true;
}

static bool
_equalExecuteStmt(ExecuteStmt *a, ExecuteStmt *b)
{
      COMPARE_STRING_FIELD(name);
      COMPARE_NODE_FIELD(into);
      COMPARE_NODE_FIELD(params);

      return true;
}

static bool
_equalDeallocateStmt(DeallocateStmt *a, DeallocateStmt *b)
{
      COMPARE_STRING_FIELD(name);

      return true;
}

static bool
_equalDropOwnedStmt(DropOwnedStmt *a, DropOwnedStmt *b)
{
      COMPARE_NODE_FIELD(roles);
      COMPARE_SCALAR_FIELD(behavior);

      return true;
}

static bool
_equalReassignOwnedStmt(ReassignOwnedStmt *a, ReassignOwnedStmt *b)
{
      COMPARE_NODE_FIELD(roles);
      COMPARE_NODE_FIELD(newrole);

      return true;
}

static bool
_equalAlterTSDictionaryStmt(AlterTSDictionaryStmt *a, AlterTSDictionaryStmt *b)
{
      COMPARE_NODE_FIELD(dictname);
      COMPARE_NODE_FIELD(options);

      return true;
}

static bool
_equalAlterTSConfigurationStmt(AlterTSConfigurationStmt *a,
                                             AlterTSConfigurationStmt *b)
{
      COMPARE_NODE_FIELD(cfgname);
      COMPARE_NODE_FIELD(tokentype);
      COMPARE_NODE_FIELD(dicts);
      COMPARE_SCALAR_FIELD(override);
      COMPARE_SCALAR_FIELD(replace);
      COMPARE_SCALAR_FIELD(missing_ok);

      return true;
}

static bool
_equalAExpr(A_Expr *a, A_Expr *b)
{
      COMPARE_SCALAR_FIELD(kind);
      COMPARE_NODE_FIELD(name);
      COMPARE_NODE_FIELD(lexpr);
      COMPARE_NODE_FIELD(rexpr);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalColumnRef(ColumnRef *a, ColumnRef *b)
{
      COMPARE_NODE_FIELD(fields);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalParamRef(ParamRef *a, ParamRef *b)
{
      COMPARE_SCALAR_FIELD(number);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalAConst(A_Const *a, A_Const *b)
{
      if (!equal(&a->val, &b->val))       /* hack for in-line Value field */
            return false;
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalFuncCall(FuncCall *a, FuncCall *b)
{
      COMPARE_NODE_FIELD(funcname);
      COMPARE_NODE_FIELD(args);
      COMPARE_SCALAR_FIELD(agg_star);
      COMPARE_SCALAR_FIELD(agg_distinct);
      COMPARE_SCALAR_FIELD(func_variadic);
      COMPARE_NODE_FIELD(over);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalAStar(A_Star *a, A_Star *b)
{
      return true;
}

static bool
_equalAIndices(A_Indices *a, A_Indices *b)
{
      COMPARE_NODE_FIELD(lidx);
      COMPARE_NODE_FIELD(uidx);

      return true;
}

static bool
_equalA_Indirection(A_Indirection *a, A_Indirection *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_NODE_FIELD(indirection);

      return true;
}

static bool
_equalA_ArrayExpr(A_ArrayExpr *a, A_ArrayExpr *b)
{
      COMPARE_NODE_FIELD(elements);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalResTarget(ResTarget *a, ResTarget *b)
{
      COMPARE_STRING_FIELD(name);
      COMPARE_NODE_FIELD(indirection);
      COMPARE_NODE_FIELD(val);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalTypeName(TypeName *a, TypeName *b)
{
      COMPARE_NODE_FIELD(names);
      COMPARE_SCALAR_FIELD(typeid);
      COMPARE_SCALAR_FIELD(setof);
      COMPARE_SCALAR_FIELD(pct_type);
      COMPARE_NODE_FIELD(typmods);
      COMPARE_SCALAR_FIELD(typemod);
      COMPARE_NODE_FIELD(arrayBounds);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalTypeCast(TypeCast *a, TypeCast *b)
{
      COMPARE_NODE_FIELD(arg);
      COMPARE_NODE_FIELD(typename);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalSortBy(SortBy *a, SortBy *b)
{
      COMPARE_NODE_FIELD(node);
      COMPARE_SCALAR_FIELD(sortby_dir);
      COMPARE_SCALAR_FIELD(sortby_nulls);
      COMPARE_NODE_FIELD(useOp);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalWindowDef(WindowDef *a, WindowDef *b)
{
      COMPARE_STRING_FIELD(name);
      COMPARE_STRING_FIELD(refname);
      COMPARE_NODE_FIELD(partitionClause);
      COMPARE_NODE_FIELD(orderClause);
      COMPARE_SCALAR_FIELD(frameOptions);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalRangeSubselect(RangeSubselect *a, RangeSubselect *b)
{
      COMPARE_NODE_FIELD(subquery);
      COMPARE_NODE_FIELD(alias);

      return true;
}

static bool
_equalRangeFunction(RangeFunction *a, RangeFunction *b)
{
      COMPARE_NODE_FIELD(funccallnode);
      COMPARE_NODE_FIELD(alias);
      COMPARE_NODE_FIELD(coldeflist);

      return true;
}

static bool
_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;
}

static bool
_equalColumnDef(ColumnDef *a, ColumnDef *b)
{
      COMPARE_STRING_FIELD(colname);
      COMPARE_NODE_FIELD(typename);
      COMPARE_SCALAR_FIELD(inhcount);
      COMPARE_SCALAR_FIELD(is_local);
      COMPARE_SCALAR_FIELD(is_not_null);
      COMPARE_NODE_FIELD(raw_default);
      COMPARE_STRING_FIELD(cooked_default);
      COMPARE_NODE_FIELD(constraints);

      return true;
}

static bool
_equalConstraint(Constraint *a, Constraint *b)
{
      COMPARE_SCALAR_FIELD(contype);
      COMPARE_STRING_FIELD(name);
      COMPARE_NODE_FIELD(raw_expr);
      COMPARE_STRING_FIELD(cooked_expr);
      COMPARE_NODE_FIELD(keys);
      COMPARE_NODE_FIELD(options);
      COMPARE_STRING_FIELD(indexspace);

      return true;
}

static bool
_equalDefElem(DefElem *a, DefElem *b)
{
      COMPARE_STRING_FIELD(defnamespace);
      COMPARE_STRING_FIELD(defname);
      COMPARE_NODE_FIELD(arg);
      COMPARE_SCALAR_FIELD(defaction);

      return true;
}

static bool
_equalLockingClause(LockingClause *a, LockingClause *b)
{
      COMPARE_NODE_FIELD(lockedRels);
      COMPARE_SCALAR_FIELD(forUpdate);
      COMPARE_SCALAR_FIELD(noWait);

      return true;
}

static bool
_equalRangeTblEntry(RangeTblEntry *a, RangeTblEntry *b)
{
      COMPARE_SCALAR_FIELD(rtekind);
      COMPARE_SCALAR_FIELD(relid);
      COMPARE_NODE_FIELD(subquery);
      COMPARE_SCALAR_FIELD(jointype);
      COMPARE_NODE_FIELD(joinaliasvars);
      COMPARE_NODE_FIELD(funcexpr);
      COMPARE_NODE_FIELD(funccoltypes);
      COMPARE_NODE_FIELD(funccoltypmods);
      COMPARE_NODE_FIELD(values_lists);
      COMPARE_STRING_FIELD(ctename);
      COMPARE_SCALAR_FIELD(ctelevelsup);
      COMPARE_SCALAR_FIELD(self_reference);
      COMPARE_NODE_FIELD(ctecoltypes);
      COMPARE_NODE_FIELD(ctecoltypmods);
      COMPARE_NODE_FIELD(alias);
      COMPARE_NODE_FIELD(eref);
      COMPARE_SCALAR_FIELD(inh);
      COMPARE_SCALAR_FIELD(inFromCl);
      COMPARE_SCALAR_FIELD(requiredPerms);
      COMPARE_SCALAR_FIELD(checkAsUser);
      COMPARE_BITMAPSET_FIELD(selectedCols);
      COMPARE_BITMAPSET_FIELD(modifiedCols);

      return true;
}

static bool
_equalSortGroupClause(SortGroupClause *a, SortGroupClause *b)
{
      COMPARE_SCALAR_FIELD(tleSortGroupRef);
      COMPARE_SCALAR_FIELD(eqop);
      COMPARE_SCALAR_FIELD(sortop);
      COMPARE_SCALAR_FIELD(nulls_first);

      return true;
}

static bool
_equalWindowClause(WindowClause *a, WindowClause *b)
{
      COMPARE_STRING_FIELD(name);
      COMPARE_STRING_FIELD(refname);
      COMPARE_NODE_FIELD(partitionClause);
      COMPARE_NODE_FIELD(orderClause);
      COMPARE_SCALAR_FIELD(frameOptions);
      COMPARE_SCALAR_FIELD(winref);
      COMPARE_SCALAR_FIELD(copiedOrder);

      return true;
}

static bool
_equalRowMarkClause(RowMarkClause *a, RowMarkClause *b)
{
      COMPARE_SCALAR_FIELD(rti);
      COMPARE_SCALAR_FIELD(prti);
      COMPARE_SCALAR_FIELD(forUpdate);
      COMPARE_SCALAR_FIELD(noWait);
      COMPARE_SCALAR_FIELD(isParent);

      return true;
}

static bool
_equalWithClause(WithClause *a, WithClause *b)
{
      COMPARE_NODE_FIELD(ctes);
      COMPARE_SCALAR_FIELD(recursive);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

static bool
_equalCommonTableExpr(CommonTableExpr *a, CommonTableExpr *b)
{
      COMPARE_STRING_FIELD(ctename);
      COMPARE_NODE_FIELD(aliascolnames);
      COMPARE_NODE_FIELD(ctequery);
      COMPARE_LOCATION_FIELD(location);
      COMPARE_SCALAR_FIELD(cterecursive);
      COMPARE_SCALAR_FIELD(cterefcount);
      COMPARE_NODE_FIELD(ctecolnames);
      COMPARE_NODE_FIELD(ctecoltypes);
      COMPARE_NODE_FIELD(ctecoltypmods);

      return true;
}

static bool
_equalFkConstraint(FkConstraint *a, FkConstraint *b)
{
      COMPARE_STRING_FIELD(constr_name);
      COMPARE_NODE_FIELD(pktable);
      COMPARE_NODE_FIELD(fk_attrs);
      COMPARE_NODE_FIELD(pk_attrs);
      COMPARE_SCALAR_FIELD(fk_matchtype);
      COMPARE_SCALAR_FIELD(fk_upd_action);
      COMPARE_SCALAR_FIELD(fk_del_action);
      COMPARE_SCALAR_FIELD(deferrable);
      COMPARE_SCALAR_FIELD(initdeferred);
      COMPARE_SCALAR_FIELD(skip_validation);

      return true;
}

static bool
_equalXmlSerialize(XmlSerialize *a, XmlSerialize *b)
{
      COMPARE_SCALAR_FIELD(xmloption);
      COMPARE_NODE_FIELD(expr);
      COMPARE_NODE_FIELD(typename);
      COMPARE_LOCATION_FIELD(location);

      return true;
}

/*
 * Stuff from pg_list.h
 */

static bool
_equalList(List *a, List *b)
{
      ListCell   *item_a;
      ListCell   *item_b;

      /*
       * Try to reject by simple scalar checks before grovelling through all the
       * list elements...
       */
      COMPARE_SCALAR_FIELD(type);
      COMPARE_SCALAR_FIELD(length);

      /*
       * We place the switch outside the loop for the sake of efficiency; this
       * may not be worth doing...
       */
      switch (a->type)
      {
            case T_List:
                  forboth(item_a, a, item_b, b)
                  {
                        if (!equal(lfirst(item_a), lfirst(item_b)))
                              return false;
                  }
                  break;
            case T_IntList:
                  forboth(item_a, a, item_b, b)
                  {
                        if (lfirst_int(item_a) != lfirst_int(item_b))
                              return false;
                  }
                  break;
            case T_OidList:
                  forboth(item_a, a, item_b, b)
                  {
                        if (lfirst_oid(item_a) != lfirst_oid(item_b))
                              return false;
                  }
                  break;
            default:
                  elog(ERROR, "unrecognized list node type: %d",
                         (int) a->type);
                  return false;           /* keep compiler quiet */
      }

      /*
       * If we got here, we should have run out of elements of both lists
       */
      Assert(item_a == NULL);
      Assert(item_b == NULL);

      return true;
}

/*
 * Stuff from value.h
 */

static bool
_equalValue(Value *a, Value *b)
{
      COMPARE_SCALAR_FIELD(type);

      switch (a->type)
      {
            case T_Integer:
                  COMPARE_SCALAR_FIELD(val.ival);
                  break;
            case T_Float:
            case T_String:
            case T_BitString:
                  COMPARE_STRING_FIELD(val.str);
                  break;
            case T_Null:
                  /* nothing to do */
                  break;
            default:
                  elog(ERROR, "unrecognized node type: %d", (int) a->type);
                  break;
      }

      return true;
}

/*
 * equal
 *      returns whether two nodes are equal
 */
bool
equal(void *a, void *b)
{
      bool        retval;

      if (a == b)
            return true;

      /*
       * note that a!=b, so only one of them can be NULL
       */
      if (a == NULL || b == NULL)
            return false;

      /*
       * are they the same type of nodes?
       */
      if (nodeTag(a) != nodeTag(b))
            return false;

      switch (nodeTag(a))
      {
                  /*
                   * PRIMITIVE NODES
                   */
            case T_Alias:
                  retval = _equalAlias(a, b);
                  break;
            case T_RangeVar:
                  retval = _equalRangeVar(a, b);
                  break;
            case T_IntoClause:
                  retval = _equalIntoClause(a, b);
                  break;
            case T_Var:
                  retval = _equalVar(a, b);
                  break;
            case T_Const:
                  retval = _equalConst(a, b);
                  break;
            case T_Param:
                  retval = _equalParam(a, b);
                  break;
            case T_Aggref:
                  retval = _equalAggref(a, b);
                  break;
            case T_WindowFunc:
                  retval = _equalWindowFunc(a, b);
                  break;
            case T_ArrayRef:
                  retval = _equalArrayRef(a, b);
                  break;
            case T_FuncExpr:
                  retval = _equalFuncExpr(a, b);
                  break;
            case T_OpExpr:
                  retval = _equalOpExpr(a, b);
                  break;
            case T_DistinctExpr:
                  retval = _equalDistinctExpr(a, b);
                  break;
            case T_ScalarArrayOpExpr:
                  retval = _equalScalarArrayOpExpr(a, b);
                  break;
            case T_BoolExpr:
                  retval = _equalBoolExpr(a, b);
                  break;
            case T_SubLink:
                  retval = _equalSubLink(a, b);
                  break;
            case T_SubPlan:
                  retval = _equalSubPlan(a, b);
                  break;
            case T_AlternativeSubPlan:
                  retval = _equalAlternativeSubPlan(a, b);
                  break;
            case T_FieldSelect:
                  retval = _equalFieldSelect(a, b);
                  break;
            case T_FieldStore:
                  retval = _equalFieldStore(a, b);
                  break;
            case T_RelabelType:
                  retval = _equalRelabelType(a, b);
                  break;
            case T_CoerceViaIO:
                  retval = _equalCoerceViaIO(a, b);
                  break;
            case T_ArrayCoerceExpr:
                  retval = _equalArrayCoerceExpr(a, b);
                  break;
            case T_ConvertRowtypeExpr:
                  retval = _equalConvertRowtypeExpr(a, b);
                  break;
            case T_CaseExpr:
                  retval = _equalCaseExpr(a, b);
                  break;
            case T_CaseWhen:
                  retval = _equalCaseWhen(a, b);
                  break;
            case T_CaseTestExpr:
                  retval = _equalCaseTestExpr(a, b);
                  break;
            case T_ArrayExpr:
                  retval = _equalArrayExpr(a, b);
                  break;
            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;
            case T_NullTest:
                  retval = _equalNullTest(a, b);
                  break;
            case T_BooleanTest:
                  retval = _equalBooleanTest(a, b);
                  break;
            case T_CoerceToDomain:
                  retval = _equalCoerceToDomain(a, b);
                  break;
            case T_CoerceToDomainValue:
                  retval = _equalCoerceToDomainValue(a, b);
                  break;
            case T_SetToDefault:
                  retval = _equalSetToDefault(a, b);
                  break;
            case T_CurrentOfExpr:
                  retval = _equalCurrentOfExpr(a, b);
                  break;
            case T_TargetEntry:
                  retval = _equalTargetEntry(a, b);
                  break;
            case T_RangeTblRef:
                  retval = _equalRangeTblRef(a, b);
                  break;
            case T_FromExpr:
                  retval = _equalFromExpr(a, b);
                  break;
            case T_JoinExpr:
                  retval = _equalJoinExpr(a, b);
                  break;

                  /*
                   * RELATION NODES
                   */
            case T_PathKey:
                  retval = _equalPathKey(a, b);
                  break;
            case T_RestrictInfo:
                  retval = _equalRestrictInfo(a, b);
                  break;
            case T_PlaceHolderVar:
                  retval = _equalPlaceHolderVar(a, b);
                  break;
            case T_SpecialJoinInfo:
                  retval = _equalSpecialJoinInfo(a, b);
                  break;
            case T_AppendRelInfo:
                  retval = _equalAppendRelInfo(a, b);
                  break;
            case T_PlaceHolderInfo:
                  retval = _equalPlaceHolderInfo(a, b);
                  break;

            case T_List:
            case T_IntList:
            case T_OidList:
                  retval = _equalList(a, b);
                  break;

            case T_Integer:
            case T_Float:
            case T_String:
            case T_BitString:
            case T_Null:
                  retval = _equalValue(a, b);
                  break;

                  /*
                   * PARSE NODES
                   */
            case T_Query:
                  retval = _equalQuery(a, b);
                  break;
            case T_InsertStmt:
                  retval = _equalInsertStmt(a, b);
                  break;
            case T_DeleteStmt:
                  retval = _equalDeleteStmt(a, b);
                  break;
            case T_UpdateStmt:
                  retval = _equalUpdateStmt(a, b);
                  break;
            case T_SelectStmt:
                  retval = _equalSelectStmt(a, b);
                  break;
            case T_SetOperationStmt:
                  retval = _equalSetOperationStmt(a, b);
                  break;
            case T_AlterTableStmt:
                  retval = _equalAlterTableStmt(a, b);
                  break;
            case T_AlterTableCmd:
                  retval = _equalAlterTableCmd(a, b);
                  break;
            case T_AlterDomainStmt:
                  retval = _equalAlterDomainStmt(a, b);
                  break;
            case T_GrantStmt:
                  retval = _equalGrantStmt(a, b);
                  break;
            case T_GrantRoleStmt:
                  retval = _equalGrantRoleStmt(a, b);
                  break;
            case T_DeclareCursorStmt:
                  retval = _equalDeclareCursorStmt(a, b);
                  break;
            case T_ClosePortalStmt:
                  retval = _equalClosePortalStmt(a, b);
                  break;
            case T_ClusterStmt:
                  retval = _equalClusterStmt(a, b);
                  break;
            case T_CopyStmt:
                  retval = _equalCopyStmt(a, b);
                  break;
            case T_CreateStmt:
                  retval = _equalCreateStmt(a, b);
                  break;
            case T_InhRelation:
                  retval = _equalInhRelation(a, b);
                  break;
            case T_DefineStmt:
                  retval = _equalDefineStmt(a, b);
                  break;
            case T_DropStmt:
                  retval = _equalDropStmt(a, b);
                  break;
            case T_TruncateStmt:
                  retval = _equalTruncateStmt(a, b);
                  break;
            case T_CommentStmt:
                  retval = _equalCommentStmt(a, b);
                  break;
            case T_FetchStmt:
                  retval = _equalFetchStmt(a, b);
                  break;
            case T_IndexStmt:
                  retval = _equalIndexStmt(a, b);
                  break;
            case T_CreateFunctionStmt:
                  retval = _equalCreateFunctionStmt(a, b);
                  break;
            case T_FunctionParameter:
                  retval = _equalFunctionParameter(a, b);
                  break;
            case T_AlterFunctionStmt:
                  retval = _equalAlterFunctionStmt(a, b);
                  break;
            case T_RemoveFuncStmt:
                  retval = _equalRemoveFuncStmt(a, b);
                  break;
            case T_RemoveOpClassStmt:
                  retval = _equalRemoveOpClassStmt(a, b);
                  break;
            case T_RemoveOpFamilyStmt:
                  retval = _equalRemoveOpFamilyStmt(a, b);
                  break;
            case T_RenameStmt:
                  retval = _equalRenameStmt(a, b);
                  break;
            case T_AlterObjectSchemaStmt:
                  retval = _equalAlterObjectSchemaStmt(a, b);
                  break;
            case T_AlterOwnerStmt:
                  retval = _equalAlterOwnerStmt(a, b);
                  break;
            case T_RuleStmt:
                  retval = _equalRuleStmt(a, b);
                  break;
            case T_NotifyStmt:
                  retval = _equalNotifyStmt(a, b);
                  break;
            case T_ListenStmt:
                  retval = _equalListenStmt(a, b);
                  break;
            case T_UnlistenStmt:
                  retval = _equalUnlistenStmt(a, b);
                  break;
            case T_TransactionStmt:
                  retval = _equalTransactionStmt(a, b);
                  break;
            case T_CompositeTypeStmt:
                  retval = _equalCompositeTypeStmt(a, b);
                  break;
            case T_CreateEnumStmt:
                  retval = _equalCreateEnumStmt(a, b);
                  break;
            case T_ViewStmt:
                  retval = _equalViewStmt(a, b);
                  break;
            case T_LoadStmt:
                  retval = _equalLoadStmt(a, b);
                  break;
            case T_CreateDomainStmt:
                  retval = _equalCreateDomainStmt(a, b);
                  break;
            case T_CreateOpClassStmt:
                  retval = _equalCreateOpClassStmt(a, b);
                  break;
            case T_CreateOpClassItem:
                  retval = _equalCreateOpClassItem(a, b);
                  break;
            case T_CreateOpFamilyStmt:
                  retval = _equalCreateOpFamilyStmt(a, b);
                  break;
            case T_AlterOpFamilyStmt:
                  retval = _equalAlterOpFamilyStmt(a, b);
                  break;
            case T_CreatedbStmt:
                  retval = _equalCreatedbStmt(a, b);
                  break;
            case T_AlterDatabaseStmt:
                  retval = _equalAlterDatabaseStmt(a, b);
                  break;
            case T_AlterDatabaseSetStmt:
                  retval = _equalAlterDatabaseSetStmt(a, b);
                  break;
            case T_DropdbStmt:
                  retval = _equalDropdbStmt(a, b);
                  break;
            case T_VacuumStmt:
                  retval = _equalVacuumStmt(a, b);
                  break;
            case T_ExplainStmt:
                  retval = _equalExplainStmt(a, b);
                  break;
            case T_CreateSeqStmt:
                  retval = _equalCreateSeqStmt(a, b);
                  break;
            case T_AlterSeqStmt:
                  retval = _equalAlterSeqStmt(a, b);
                  break;
            case T_VariableSetStmt:
                  retval = _equalVariableSetStmt(a, b);
                  break;
            case T_VariableShowStmt:
                  retval = _equalVariableShowStmt(a, b);
                  break;
            case T_DiscardStmt:
                  retval = _equalDiscardStmt(a, b);
                  break;
            case T_CreateTableSpaceStmt:
                  retval = _equalCreateTableSpaceStmt(a, b);
                  break;
            case T_DropTableSpaceStmt:
                  retval = _equalDropTableSpaceStmt(a, b);
                  break;
            case T_CreateFdwStmt:
                  retval = _equalCreateFdwStmt(a, b);
                  break;
            case T_AlterFdwStmt:
                  retval = _equalAlterFdwStmt(a, b);
                  break;
            case T_DropFdwStmt:
                  retval = _equalDropFdwStmt(a, b);
                  break;
            case T_CreateForeignServerStmt:
                  retval = _equalCreateForeignServerStmt(a, b);
                  break;
            case T_AlterForeignServerStmt:
                  retval = _equalAlterForeignServerStmt(a, b);
                  break;
            case T_DropForeignServerStmt:
                  retval = _equalDropForeignServerStmt(a, b);
                  break;
            case T_CreateUserMappingStmt:
                  retval = _equalCreateUserMappingStmt(a, b);
                  break;
            case T_AlterUserMappingStmt:
                  retval = _equalAlterUserMappingStmt(a, b);
                  break;
            case T_DropUserMappingStmt:
                  retval = _equalDropUserMappingStmt(a, b);
                  break;
            case T_CreateTrigStmt:
                  retval = _equalCreateTrigStmt(a, b);
                  break;
            case T_DropPropertyStmt:
                  retval = _equalDropPropertyStmt(a, b);
                  break;
            case T_CreatePLangStmt:
                  retval = _equalCreatePLangStmt(a, b);
                  break;
            case T_DropPLangStmt:
                  retval = _equalDropPLangStmt(a, b);
                  break;
            case T_CreateRoleStmt:
                  retval = _equalCreateRoleStmt(a, b);
                  break;
            case T_AlterRoleStmt:
                  retval = _equalAlterRoleStmt(a, b);
                  break;
            case T_AlterRoleSetStmt:
                  retval = _equalAlterRoleSetStmt(a, b);
                  break;
            case T_DropRoleStmt:
                  retval = _equalDropRoleStmt(a, b);
                  break;
            case T_LockStmt:
                  retval = _equalLockStmt(a, b);
                  break;
            case T_ConstraintsSetStmt:
                  retval = _equalConstraintsSetStmt(a, b);
                  break;
            case T_ReindexStmt:
                  retval = _equalReindexStmt(a, b);
                  break;
            case T_CheckPointStmt:
                  retval = true;
                  break;
            case T_CreateSchemaStmt:
                  retval = _equalCreateSchemaStmt(a, b);
                  break;
            case T_CreateConversionStmt:
                  retval = _equalCreateConversionStmt(a, b);
                  break;
            case T_CreateCastStmt:
                  retval = _equalCreateCastStmt(a, b);
                  break;
            case T_DropCastStmt:
                  retval = _equalDropCastStmt(a, b);
                  break;
            case T_PrepareStmt:
                  retval = _equalPrepareStmt(a, b);
                  break;
            case T_ExecuteStmt:
                  retval = _equalExecuteStmt(a, b);
                  break;
            case T_DeallocateStmt:
                  retval = _equalDeallocateStmt(a, b);
                  break;
            case T_DropOwnedStmt:
                  retval = _equalDropOwnedStmt(a, b);
                  break;
            case T_ReassignOwnedStmt:
                  retval = _equalReassignOwnedStmt(a, b);
                  break;
            case T_AlterTSDictionaryStmt:
                  retval = _equalAlterTSDictionaryStmt(a, b);
                  break;
            case T_AlterTSConfigurationStmt:
                  retval = _equalAlterTSConfigurationStmt(a, b);
                  break;

            case T_A_Expr:
                  retval = _equalAExpr(a, b);
                  break;
            case T_ColumnRef:
                  retval = _equalColumnRef(a, b);
                  break;
            case T_ParamRef:
                  retval = _equalParamRef(a, b);
                  break;
            case T_A_Const:
                  retval = _equalAConst(a, b);
                  break;
            case T_FuncCall:
                  retval = _equalFuncCall(a, b);
                  break;
            case T_A_Star:
                  retval = _equalAStar(a, b);
                  break;
            case T_A_Indices:
                  retval = _equalAIndices(a, b);
                  break;
            case T_A_Indirection:
                  retval = _equalA_Indirection(a, b);
                  break;
            case T_A_ArrayExpr:
                  retval = _equalA_ArrayExpr(a, b);
                  break;
            case T_ResTarget:
                  retval = _equalResTarget(a, b);
                  break;
            case T_TypeCast:
                  retval = _equalTypeCast(a, b);
                  break;
            case T_SortBy:
                  retval = _equalSortBy(a, b);
                  break;
            case T_WindowDef:
                  retval = _equalWindowDef(a, b);
                  break;
            case T_RangeSubselect:
                  retval = _equalRangeSubselect(a, b);
                  break;
            case T_RangeFunction:
                  retval = _equalRangeFunction(a, b);
                  break;
            case T_TypeName:
                  retval = _equalTypeName(a, b);
                  break;
            case T_IndexElem:
                  retval = _equalIndexElem(a, b);
                  break;
            case T_ColumnDef:
                  retval = _equalColumnDef(a, b);
                  break;
            case T_Constraint:
                  retval = _equalConstraint(a, b);
                  break;
            case T_DefElem:
                  retval = _equalDefElem(a, b);
                  break;
            case T_LockingClause:
                  retval = _equalLockingClause(a, b);
                  break;
            case T_RangeTblEntry:
                  retval = _equalRangeTblEntry(a, b);
                  break;
            case T_SortGroupClause:
                  retval = _equalSortGroupClause(a, b);
                  break;
            case T_WindowClause:
                  retval = _equalWindowClause(a, b);
                  break;
            case T_RowMarkClause:
                  retval = _equalRowMarkClause(a, b);
                  break;
            case T_WithClause:
                  retval = _equalWithClause(a, b);
                  break;
            case T_CommonTableExpr:
                  retval = _equalCommonTableExpr(a, b);
                  break;
            case T_FkConstraint:
                  retval = _equalFkConstraint(a, b);
                  break;
            case T_PrivGrantee:
                  retval = _equalPrivGrantee(a, b);
                  break;
            case T_FuncWithArgs:
                  retval = _equalFuncWithArgs(a, b);
                  break;
            case T_AccessPriv:
                  retval = _equalAccessPriv(a, b);
                  break;
            case T_XmlSerialize:
                  retval = _equalXmlSerialize(a, b);
                  break;

            default:
                  elog(ERROR, "unrecognized node type: %d",
                         (int) nodeTag(a));
                  retval = false;         /* keep compiler quiet */
                  break;
      }

      return retval;
}

Generated by  Doxygen 1.6.0   Back to index