diff options
Diffstat (limited to 'src/backend/nodes/equalfuncs.c')
| -rw-r--r-- | src/backend/nodes/equalfuncs.c | 3771 |
1 files changed, 3771 insertions, 0 deletions
diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c new file mode 100644 index 0000000..8dc50ae --- /dev/null +++ b/src/backend/nodes/equalfuncs.c @@ -0,0 +1,3771 @@ +/*------------------------------------------------------------------------- + * + * 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-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * IDENTIFICATION + * src/backend/nodes/equalfuncs.c + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "miscadmin.h" +#include "nodes/extensible.h" +#include "nodes/pathnodes.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) + +/* Compare a CoercionForm field (also a no-op, per comment in primnodes.h) */ +#define COMPARE_COERCIONFORM_FIELD(fldname) \ + ((void) 0) + + +/* + * Stuff from primnodes.h + */ + +static bool +_equalAlias(const Alias *a, const Alias *b) +{ + COMPARE_STRING_FIELD(aliasname); + COMPARE_NODE_FIELD(colnames); + + return true; +} + +static bool +_equalRangeVar(const RangeVar *a, const RangeVar *b) +{ + COMPARE_STRING_FIELD(catalogname); + COMPARE_STRING_FIELD(schemaname); + COMPARE_STRING_FIELD(relname); + COMPARE_SCALAR_FIELD(inh); + COMPARE_SCALAR_FIELD(relpersistence); + COMPARE_NODE_FIELD(alias); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalTableFunc(const TableFunc *a, const TableFunc *b) +{ + COMPARE_NODE_FIELD(ns_uris); + COMPARE_NODE_FIELD(ns_names); + COMPARE_NODE_FIELD(docexpr); + COMPARE_NODE_FIELD(rowexpr); + COMPARE_NODE_FIELD(colnames); + COMPARE_NODE_FIELD(coltypes); + COMPARE_NODE_FIELD(coltypmods); + COMPARE_NODE_FIELD(colcollations); + COMPARE_NODE_FIELD(colexprs); + COMPARE_NODE_FIELD(coldefexprs); + COMPARE_BITMAPSET_FIELD(notnulls); + COMPARE_SCALAR_FIELD(ordinalitycol); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalIntoClause(const IntoClause *a, const IntoClause *b) +{ + COMPARE_NODE_FIELD(rel); + COMPARE_NODE_FIELD(colNames); + COMPARE_STRING_FIELD(accessMethod); + COMPARE_NODE_FIELD(options); + COMPARE_SCALAR_FIELD(onCommit); + COMPARE_STRING_FIELD(tableSpaceName); + COMPARE_NODE_FIELD(viewQuery); + COMPARE_SCALAR_FIELD(skipData); + + 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(const Var *a, const Var *b) +{ + COMPARE_SCALAR_FIELD(varno); + COMPARE_SCALAR_FIELD(varattno); + COMPARE_SCALAR_FIELD(vartype); + COMPARE_SCALAR_FIELD(vartypmod); + COMPARE_SCALAR_FIELD(varcollid); + COMPARE_SCALAR_FIELD(varlevelsup); + + /* + * varnosyn/varattnosyn are intentionally ignored here, because Vars with + * different syntactic identifiers are semantically the same as long as + * their varno/varattno match. + */ + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalConst(const Const *a, const Const *b) +{ + COMPARE_SCALAR_FIELD(consttype); + COMPARE_SCALAR_FIELD(consttypmod); + COMPARE_SCALAR_FIELD(constcollid); + 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(const Param *a, const Param *b) +{ + COMPARE_SCALAR_FIELD(paramkind); + COMPARE_SCALAR_FIELD(paramid); + COMPARE_SCALAR_FIELD(paramtype); + COMPARE_SCALAR_FIELD(paramtypmod); + COMPARE_SCALAR_FIELD(paramcollid); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalAggref(const Aggref *a, const Aggref *b) +{ + COMPARE_SCALAR_FIELD(aggfnoid); + COMPARE_SCALAR_FIELD(aggtype); + COMPARE_SCALAR_FIELD(aggcollid); + COMPARE_SCALAR_FIELD(inputcollid); + /* ignore aggtranstype since it might not be set yet */ + COMPARE_NODE_FIELD(aggargtypes); + COMPARE_NODE_FIELD(aggdirectargs); + COMPARE_NODE_FIELD(args); + COMPARE_NODE_FIELD(aggorder); + COMPARE_NODE_FIELD(aggdistinct); + COMPARE_NODE_FIELD(aggfilter); + COMPARE_SCALAR_FIELD(aggstar); + COMPARE_SCALAR_FIELD(aggvariadic); + COMPARE_SCALAR_FIELD(aggkind); + COMPARE_SCALAR_FIELD(agglevelsup); + COMPARE_SCALAR_FIELD(aggsplit); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalGroupingFunc(const GroupingFunc *a, const GroupingFunc *b) +{ + COMPARE_NODE_FIELD(args); + + /* + * We must not compare the refs or cols field + */ + + COMPARE_SCALAR_FIELD(agglevelsup); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalWindowFunc(const WindowFunc *a, const WindowFunc *b) +{ + COMPARE_SCALAR_FIELD(winfnoid); + COMPARE_SCALAR_FIELD(wintype); + COMPARE_SCALAR_FIELD(wincollid); + COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_NODE_FIELD(args); + COMPARE_NODE_FIELD(aggfilter); + COMPARE_SCALAR_FIELD(winref); + COMPARE_SCALAR_FIELD(winstar); + COMPARE_SCALAR_FIELD(winagg); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalSubscriptingRef(const SubscriptingRef *a, const SubscriptingRef *b) +{ + COMPARE_SCALAR_FIELD(refcontainertype); + COMPARE_SCALAR_FIELD(refelemtype); + COMPARE_SCALAR_FIELD(reftypmod); + COMPARE_SCALAR_FIELD(refcollid); + COMPARE_NODE_FIELD(refupperindexpr); + COMPARE_NODE_FIELD(reflowerindexpr); + COMPARE_NODE_FIELD(refexpr); + COMPARE_NODE_FIELD(refassgnexpr); + + return true; +} + +static bool +_equalFuncExpr(const FuncExpr *a, const FuncExpr *b) +{ + COMPARE_SCALAR_FIELD(funcid); + COMPARE_SCALAR_FIELD(funcresulttype); + COMPARE_SCALAR_FIELD(funcretset); + COMPARE_SCALAR_FIELD(funcvariadic); + COMPARE_COERCIONFORM_FIELD(funcformat); + COMPARE_SCALAR_FIELD(funccollid); + COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_NODE_FIELD(args); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_STRING_FIELD(name); + COMPARE_SCALAR_FIELD(argnumber); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalOpExpr(const OpExpr *a, const 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_SCALAR_FIELD(opcollid); + COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_NODE_FIELD(args); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalDistinctExpr(const DistinctExpr *a, const 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_SCALAR_FIELD(opcollid); + COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_NODE_FIELD(args); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalNullIfExpr(const NullIfExpr *a, const 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_SCALAR_FIELD(opcollid); + COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_NODE_FIELD(args); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const 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_SCALAR_FIELD(inputcollid); + COMPARE_NODE_FIELD(args); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalBoolExpr(const BoolExpr *a, const BoolExpr *b) +{ + COMPARE_SCALAR_FIELD(boolop); + COMPARE_NODE_FIELD(args); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalSubLink(const SubLink *a, const SubLink *b) +{ + COMPARE_SCALAR_FIELD(subLinkType); + COMPARE_SCALAR_FIELD(subLinkId); + COMPARE_NODE_FIELD(testexpr); + COMPARE_NODE_FIELD(operName); + COMPARE_NODE_FIELD(subselect); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalSubPlan(const SubPlan *a, const 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(firstColCollation); + COMPARE_SCALAR_FIELD(useHashTable); + COMPARE_SCALAR_FIELD(unknownEqFalse); + COMPARE_SCALAR_FIELD(parallel_safe); + 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(const AlternativeSubPlan *a, const AlternativeSubPlan *b) +{ + COMPARE_NODE_FIELD(subplans); + + return true; +} + +static bool +_equalFieldSelect(const FieldSelect *a, const FieldSelect *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_SCALAR_FIELD(fieldnum); + COMPARE_SCALAR_FIELD(resulttype); + COMPARE_SCALAR_FIELD(resulttypmod); + COMPARE_SCALAR_FIELD(resultcollid); + + return true; +} + +static bool +_equalFieldStore(const FieldStore *a, const FieldStore *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_NODE_FIELD(newvals); + COMPARE_NODE_FIELD(fieldnums); + COMPARE_SCALAR_FIELD(resulttype); + + return true; +} + +static bool +_equalRelabelType(const RelabelType *a, const RelabelType *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_SCALAR_FIELD(resulttype); + COMPARE_SCALAR_FIELD(resulttypmod); + COMPARE_SCALAR_FIELD(resultcollid); + COMPARE_COERCIONFORM_FIELD(relabelformat); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalCoerceViaIO(const CoerceViaIO *a, const CoerceViaIO *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_SCALAR_FIELD(resulttype); + COMPARE_SCALAR_FIELD(resultcollid); + COMPARE_COERCIONFORM_FIELD(coerceformat); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalArrayCoerceExpr(const ArrayCoerceExpr *a, const ArrayCoerceExpr *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_NODE_FIELD(elemexpr); + COMPARE_SCALAR_FIELD(resulttype); + COMPARE_SCALAR_FIELD(resulttypmod); + COMPARE_SCALAR_FIELD(resultcollid); + COMPARE_COERCIONFORM_FIELD(coerceformat); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalConvertRowtypeExpr(const ConvertRowtypeExpr *a, const ConvertRowtypeExpr *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_SCALAR_FIELD(resulttype); + COMPARE_COERCIONFORM_FIELD(convertformat); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalCollateExpr(const CollateExpr *a, const CollateExpr *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_SCALAR_FIELD(collOid); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalCaseExpr(const CaseExpr *a, const CaseExpr *b) +{ + COMPARE_SCALAR_FIELD(casetype); + COMPARE_SCALAR_FIELD(casecollid); + COMPARE_NODE_FIELD(arg); + COMPARE_NODE_FIELD(args); + COMPARE_NODE_FIELD(defresult); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalCaseWhen(const CaseWhen *a, const CaseWhen *b) +{ + COMPARE_NODE_FIELD(expr); + COMPARE_NODE_FIELD(result); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b) +{ + COMPARE_SCALAR_FIELD(typeId); + COMPARE_SCALAR_FIELD(typeMod); + COMPARE_SCALAR_FIELD(collation); + + return true; +} + +static bool +_equalArrayExpr(const ArrayExpr *a, const ArrayExpr *b) +{ + COMPARE_SCALAR_FIELD(array_typeid); + COMPARE_SCALAR_FIELD(array_collid); + COMPARE_SCALAR_FIELD(element_typeid); + COMPARE_NODE_FIELD(elements); + COMPARE_SCALAR_FIELD(multidims); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalRowExpr(const RowExpr *a, const RowExpr *b) +{ + COMPARE_NODE_FIELD(args); + COMPARE_SCALAR_FIELD(row_typeid); + COMPARE_COERCIONFORM_FIELD(row_format); + COMPARE_NODE_FIELD(colnames); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalRowCompareExpr(const RowCompareExpr *a, const RowCompareExpr *b) +{ + COMPARE_SCALAR_FIELD(rctype); + COMPARE_NODE_FIELD(opnos); + COMPARE_NODE_FIELD(opfamilies); + COMPARE_NODE_FIELD(inputcollids); + COMPARE_NODE_FIELD(largs); + COMPARE_NODE_FIELD(rargs); + + return true; +} + +static bool +_equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b) +{ + COMPARE_SCALAR_FIELD(coalescetype); + COMPARE_SCALAR_FIELD(coalescecollid); + COMPARE_NODE_FIELD(args); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b) +{ + COMPARE_SCALAR_FIELD(minmaxtype); + COMPARE_SCALAR_FIELD(minmaxcollid); + COMPARE_SCALAR_FIELD(inputcollid); + COMPARE_SCALAR_FIELD(op); + COMPARE_NODE_FIELD(args); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalSQLValueFunction(const SQLValueFunction *a, const SQLValueFunction *b) +{ + COMPARE_SCALAR_FIELD(op); + COMPARE_SCALAR_FIELD(type); + COMPARE_SCALAR_FIELD(typmod); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalXmlExpr(const XmlExpr *a, const 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 +_equalNullTest(const NullTest *a, const NullTest *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_SCALAR_FIELD(nulltesttype); + COMPARE_SCALAR_FIELD(argisrow); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalBooleanTest(const BooleanTest *a, const BooleanTest *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_SCALAR_FIELD(booltesttype); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_SCALAR_FIELD(resulttype); + COMPARE_SCALAR_FIELD(resulttypmod); + COMPARE_SCALAR_FIELD(resultcollid); + COMPARE_COERCIONFORM_FIELD(coercionformat); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalCoerceToDomainValue(const CoerceToDomainValue *a, const CoerceToDomainValue *b) +{ + COMPARE_SCALAR_FIELD(typeId); + COMPARE_SCALAR_FIELD(typeMod); + COMPARE_SCALAR_FIELD(collation); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalSetToDefault(const SetToDefault *a, const SetToDefault *b) +{ + COMPARE_SCALAR_FIELD(typeId); + COMPARE_SCALAR_FIELD(typeMod); + COMPARE_SCALAR_FIELD(collation); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalCurrentOfExpr(const CurrentOfExpr *a, const CurrentOfExpr *b) +{ + COMPARE_SCALAR_FIELD(cvarno); + COMPARE_STRING_FIELD(cursor_name); + COMPARE_SCALAR_FIELD(cursor_param); + + return true; +} + +static bool +_equalNextValueExpr(const NextValueExpr *a, const NextValueExpr *b) +{ + COMPARE_SCALAR_FIELD(seqid); + COMPARE_SCALAR_FIELD(typeId); + + return true; +} + +static bool +_equalInferenceElem(const InferenceElem *a, const InferenceElem *b) +{ + COMPARE_NODE_FIELD(expr); + COMPARE_SCALAR_FIELD(infercollid); + COMPARE_SCALAR_FIELD(inferopclass); + + return true; +} + +static bool +_equalTargetEntry(const TargetEntry *a, const 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(const RangeTblRef *a, const RangeTblRef *b) +{ + COMPARE_SCALAR_FIELD(rtindex); + + return true; +} + +static bool +_equalJoinExpr(const JoinExpr *a, const JoinExpr *b) +{ + COMPARE_SCALAR_FIELD(jointype); + COMPARE_SCALAR_FIELD(isNatural); + COMPARE_NODE_FIELD(larg); + COMPARE_NODE_FIELD(rarg); + COMPARE_NODE_FIELD(usingClause); + COMPARE_NODE_FIELD(quals); + COMPARE_NODE_FIELD(alias); + COMPARE_SCALAR_FIELD(rtindex); + + return true; +} + +static bool +_equalFromExpr(const FromExpr *a, const FromExpr *b) +{ + COMPARE_NODE_FIELD(fromlist); + COMPARE_NODE_FIELD(quals); + + return true; +} + +static bool +_equalOnConflictExpr(const OnConflictExpr *a, const OnConflictExpr *b) +{ + COMPARE_SCALAR_FIELD(action); + COMPARE_NODE_FIELD(arbiterElems); + COMPARE_NODE_FIELD(arbiterWhere); + COMPARE_SCALAR_FIELD(constraint); + COMPARE_NODE_FIELD(onConflictSet); + COMPARE_NODE_FIELD(onConflictWhere); + COMPARE_SCALAR_FIELD(exclRelIndex); + COMPARE_NODE_FIELD(exclRelTlist); + + return true; +} + +/* + * Stuff from pathnodes.h + */ + +static bool +_equalPathKey(const PathKey *a, const PathKey *b) +{ + /* We assume pointer equality is sufficient to compare the eclasses */ + COMPARE_SCALAR_FIELD(pk_eclass); + COMPARE_SCALAR_FIELD(pk_opfamily); + COMPARE_SCALAR_FIELD(pk_strategy); + COMPARE_SCALAR_FIELD(pk_nulls_first); + + return true; +} + +static bool +_equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b) +{ + COMPARE_NODE_FIELD(clause); + COMPARE_SCALAR_FIELD(is_pushed_down); + COMPARE_SCALAR_FIELD(outerjoin_delayed); + COMPARE_SCALAR_FIELD(security_level); + COMPARE_BITMAPSET_FIELD(required_relids); + COMPARE_BITMAPSET_FIELD(outer_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(const PlaceHolderVar *a, const 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. This will + * happen during final plan construction when there are nested PHVs, since + * the inner PHV will get replaced by a Param in some copies of the outer + * PHV. Another way in which it can happen is that initplan sublinks + * could 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.) On + * the same reasoning, there is no need to examine phrels. + * + * COMPARE_NODE_FIELD(phexpr); + * + * COMPARE_BITMAPSET_FIELD(phrels); + */ + COMPARE_SCALAR_FIELD(phid); + COMPARE_SCALAR_FIELD(phlevelsup); + + return true; +} + +static bool +_equalSpecialJoinInfo(const SpecialJoinInfo *a, const 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_SCALAR_FIELD(semi_can_btree); + COMPARE_SCALAR_FIELD(semi_can_hash); + COMPARE_NODE_FIELD(semi_operators); + COMPARE_NODE_FIELD(semi_rhs_exprs); + + return true; +} + +static bool +_equalAppendRelInfo(const AppendRelInfo *a, const 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(num_child_cols); + COMPARE_POINTER_FIELD(parent_colnos, a->num_child_cols * sizeof(AttrNumber)); + COMPARE_SCALAR_FIELD(parent_reloid); + + return true; +} + +static bool +_equalPlaceHolderInfo(const PlaceHolderInfo *a, const PlaceHolderInfo *b) +{ + COMPARE_SCALAR_FIELD(phid); + COMPARE_NODE_FIELD(ph_var); /* should be redundant */ + COMPARE_BITMAPSET_FIELD(ph_eval_at); + COMPARE_BITMAPSET_FIELD(ph_lateral); + COMPARE_BITMAPSET_FIELD(ph_needed); + COMPARE_SCALAR_FIELD(ph_width); + + return true; +} + +/* + * Stuff from extensible.h + */ +static bool +_equalExtensibleNode(const ExtensibleNode *a, const ExtensibleNode *b) +{ + const ExtensibleNodeMethods *methods; + + COMPARE_STRING_FIELD(extnodename); + + /* At this point, we know extnodename is the same for both nodes. */ + methods = GetExtensibleNodeMethods(a->extnodename, false); + + /* compare the private fields */ + if (!methods->nodeEqual(a, b)) + return false; + + return true; +} + +/* + * Stuff from parsenodes.h + */ + +static bool +_equalQuery(const Query *a, const Query *b) +{ + COMPARE_SCALAR_FIELD(commandType); + COMPARE_SCALAR_FIELD(querySource); + /* we intentionally ignore queryId, since it might not be set */ + COMPARE_SCALAR_FIELD(canSetTag); + COMPARE_NODE_FIELD(utilityStmt); + COMPARE_SCALAR_FIELD(resultRelation); + COMPARE_SCALAR_FIELD(hasAggs); + COMPARE_SCALAR_FIELD(hasWindowFuncs); + COMPARE_SCALAR_FIELD(hasTargetSRFs); + COMPARE_SCALAR_FIELD(hasSubLinks); + COMPARE_SCALAR_FIELD(hasDistinctOn); + COMPARE_SCALAR_FIELD(hasRecursive); + COMPARE_SCALAR_FIELD(hasModifyingCTE); + COMPARE_SCALAR_FIELD(hasForUpdate); + COMPARE_SCALAR_FIELD(hasRowSecurity); + COMPARE_NODE_FIELD(cteList); + COMPARE_NODE_FIELD(rtable); + COMPARE_NODE_FIELD(jointree); + COMPARE_NODE_FIELD(targetList); + COMPARE_SCALAR_FIELD(override); + COMPARE_NODE_FIELD(onConflict); + COMPARE_NODE_FIELD(returningList); + COMPARE_NODE_FIELD(groupClause); + COMPARE_NODE_FIELD(groupingSets); + 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_SCALAR_FIELD(limitOption); + COMPARE_NODE_FIELD(rowMarks); + COMPARE_NODE_FIELD(setOperations); + COMPARE_NODE_FIELD(constraintDeps); + COMPARE_NODE_FIELD(withCheckOptions); + COMPARE_LOCATION_FIELD(stmt_location); + COMPARE_SCALAR_FIELD(stmt_len); + + return true; +} + +static bool +_equalRawStmt(const RawStmt *a, const RawStmt *b) +{ + COMPARE_NODE_FIELD(stmt); + COMPARE_LOCATION_FIELD(stmt_location); + COMPARE_SCALAR_FIELD(stmt_len); + + return true; +} + +static bool +_equalInsertStmt(const InsertStmt *a, const InsertStmt *b) +{ + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(cols); + COMPARE_NODE_FIELD(selectStmt); + COMPARE_NODE_FIELD(onConflictClause); + COMPARE_NODE_FIELD(returningList); + COMPARE_NODE_FIELD(withClause); + COMPARE_SCALAR_FIELD(override); + + return true; +} + +static bool +_equalDeleteStmt(const DeleteStmt *a, const DeleteStmt *b) +{ + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(usingClause); + COMPARE_NODE_FIELD(whereClause); + COMPARE_NODE_FIELD(returningList); + COMPARE_NODE_FIELD(withClause); + + return true; +} + +static bool +_equalUpdateStmt(const UpdateStmt *a, const UpdateStmt *b) +{ + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(targetList); + COMPARE_NODE_FIELD(whereClause); + COMPARE_NODE_FIELD(fromClause); + COMPARE_NODE_FIELD(returningList); + COMPARE_NODE_FIELD(withClause); + + return true; +} + +static bool +_equalSelectStmt(const SelectStmt *a, const 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(valuesLists); + COMPARE_NODE_FIELD(sortClause); + COMPARE_NODE_FIELD(limitOffset); + COMPARE_NODE_FIELD(limitCount); + COMPARE_SCALAR_FIELD(limitOption); + COMPARE_NODE_FIELD(lockingClause); + COMPARE_NODE_FIELD(withClause); + COMPARE_SCALAR_FIELD(op); + COMPARE_SCALAR_FIELD(all); + COMPARE_NODE_FIELD(larg); + COMPARE_NODE_FIELD(rarg); + + return true; +} + +static bool +_equalSetOperationStmt(const SetOperationStmt *a, const 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(colCollations); + COMPARE_NODE_FIELD(groupClauses); + + return true; +} + +static bool +_equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b) +{ + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(cmds); + COMPARE_SCALAR_FIELD(relkind); + COMPARE_SCALAR_FIELD(missing_ok); + + return true; +} + +static bool +_equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b) +{ + COMPARE_SCALAR_FIELD(subtype); + COMPARE_STRING_FIELD(name); + COMPARE_SCALAR_FIELD(num); + COMPARE_NODE_FIELD(newowner); + COMPARE_NODE_FIELD(def); + COMPARE_SCALAR_FIELD(behavior); + COMPARE_SCALAR_FIELD(missing_ok); + + return true; +} + +static bool +_equalAlterCollationStmt(const AlterCollationStmt *a, const AlterCollationStmt *b) +{ + COMPARE_NODE_FIELD(collname); + + return true; +} + +static bool +_equalAlterDomainStmt(const AlterDomainStmt *a, const AlterDomainStmt *b) +{ + COMPARE_SCALAR_FIELD(subtype); + COMPARE_NODE_FIELD(typeName); + COMPARE_STRING_FIELD(name); + COMPARE_NODE_FIELD(def); + COMPARE_SCALAR_FIELD(behavior); + COMPARE_SCALAR_FIELD(missing_ok); + + return true; +} + +static bool +_equalGrantStmt(const GrantStmt *a, const GrantStmt *b) +{ + COMPARE_SCALAR_FIELD(is_grant); + COMPARE_SCALAR_FIELD(targtype); + 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 +_equalObjectWithArgs(const ObjectWithArgs *a, const ObjectWithArgs *b) +{ + COMPARE_NODE_FIELD(objname); + COMPARE_NODE_FIELD(objargs); + COMPARE_SCALAR_FIELD(args_unspecified); + + return true; +} + +static bool +_equalAccessPriv(const AccessPriv *a, const AccessPriv *b) +{ + COMPARE_STRING_FIELD(priv_name); + COMPARE_NODE_FIELD(cols); + + return true; +} + +static bool +_equalGrantRoleStmt(const GrantRoleStmt *a, const GrantRoleStmt *b) +{ + COMPARE_NODE_FIELD(granted_roles); + COMPARE_NODE_FIELD(grantee_roles); + COMPARE_SCALAR_FIELD(is_grant); + COMPARE_SCALAR_FIELD(admin_opt); + COMPARE_NODE_FIELD(grantor); + COMPARE_SCALAR_FIELD(behavior); + + return true; +} + +static bool +_equalAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *a, const AlterDefaultPrivilegesStmt *b) +{ + COMPARE_NODE_FIELD(options); + COMPARE_NODE_FIELD(action); + + return true; +} + +static bool +_equalDeclareCursorStmt(const DeclareCursorStmt *a, const DeclareCursorStmt *b) +{ + COMPARE_STRING_FIELD(portalname); + COMPARE_SCALAR_FIELD(options); + COMPARE_NODE_FIELD(query); + + return true; +} + +static bool +_equalClosePortalStmt(const ClosePortalStmt *a, const ClosePortalStmt *b) +{ + COMPARE_STRING_FIELD(portalname); + + return true; +} + +static bool +_equalCallStmt(const CallStmt *a, const CallStmt *b) +{ + COMPARE_NODE_FIELD(funccall); + COMPARE_NODE_FIELD(funcexpr); + + return true; +} + +static bool +_equalClusterStmt(const ClusterStmt *a, const ClusterStmt *b) +{ + COMPARE_NODE_FIELD(relation); + COMPARE_STRING_FIELD(indexname); + COMPARE_SCALAR_FIELD(options); + + return true; +} + +static bool +_equalCopyStmt(const CopyStmt *a, const CopyStmt *b) +{ + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(query); + COMPARE_NODE_FIELD(attlist); + COMPARE_SCALAR_FIELD(is_from); + COMPARE_SCALAR_FIELD(is_program); + COMPARE_STRING_FIELD(filename); + COMPARE_NODE_FIELD(options); + COMPARE_NODE_FIELD(whereClause); + + return true; +} + +static bool +_equalCreateStmt(const CreateStmt *a, const CreateStmt *b) +{ + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(tableElts); + COMPARE_NODE_FIELD(inhRelations); + COMPARE_NODE_FIELD(partbound); + COMPARE_NODE_FIELD(partspec); + COMPARE_NODE_FIELD(ofTypename); + COMPARE_NODE_FIELD(constraints); + COMPARE_NODE_FIELD(options); + COMPARE_SCALAR_FIELD(oncommit); + COMPARE_STRING_FIELD(tablespacename); + COMPARE_STRING_FIELD(accessMethod); + COMPARE_SCALAR_FIELD(if_not_exists); + + return true; +} + +static bool +_equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b) +{ + COMPARE_NODE_FIELD(relation); + COMPARE_SCALAR_FIELD(options); + COMPARE_SCALAR_FIELD(relationOid); + + return true; +} + +static bool +_equalDefineStmt(const DefineStmt *a, const DefineStmt *b) +{ + COMPARE_SCALAR_FIELD(kind); + COMPARE_SCALAR_FIELD(oldstyle); + COMPARE_NODE_FIELD(defnames); + COMPARE_NODE_FIELD(args); + COMPARE_NODE_FIELD(definition); + COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_SCALAR_FIELD(replace); + + return true; +} + +static bool +_equalDropStmt(const DropStmt *a, const DropStmt *b) +{ + COMPARE_NODE_FIELD(objects); + COMPARE_SCALAR_FIELD(removeType); + COMPARE_SCALAR_FIELD(behavior); + COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_SCALAR_FIELD(concurrent); + + return true; +} + +static bool +_equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b) +{ + COMPARE_NODE_FIELD(relations); + COMPARE_SCALAR_FIELD(restart_seqs); + COMPARE_SCALAR_FIELD(behavior); + + return true; +} + +static bool +_equalCommentStmt(const CommentStmt *a, const CommentStmt *b) +{ + COMPARE_SCALAR_FIELD(objtype); + COMPARE_NODE_FIELD(object); + COMPARE_STRING_FIELD(comment); + + return true; +} + +static bool +_equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b) +{ + COMPARE_SCALAR_FIELD(objtype); + COMPARE_NODE_FIELD(object); + COMPARE_STRING_FIELD(provider); + COMPARE_STRING_FIELD(label); + + return true; +} + +static bool +_equalFetchStmt(const FetchStmt *a, const FetchStmt *b) +{ + COMPARE_SCALAR_FIELD(direction); + COMPARE_SCALAR_FIELD(howMany); + COMPARE_STRING_FIELD(portalname); + COMPARE_SCALAR_FIELD(ismove); + + return true; +} + +static bool +_equalIndexStmt(const IndexStmt *a, const 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(indexIncludingParams); + COMPARE_NODE_FIELD(options); + COMPARE_NODE_FIELD(whereClause); + COMPARE_NODE_FIELD(excludeOpNames); + COMPARE_STRING_FIELD(idxcomment); + COMPARE_SCALAR_FIELD(indexOid); + COMPARE_SCALAR_FIELD(oldNode); + COMPARE_SCALAR_FIELD(oldCreateSubid); + COMPARE_SCALAR_FIELD(oldFirstRelfilenodeSubid); + COMPARE_SCALAR_FIELD(unique); + COMPARE_SCALAR_FIELD(primary); + COMPARE_SCALAR_FIELD(isconstraint); + COMPARE_SCALAR_FIELD(deferrable); + COMPARE_SCALAR_FIELD(initdeferred); + COMPARE_SCALAR_FIELD(transformed); + COMPARE_SCALAR_FIELD(concurrent); + COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_SCALAR_FIELD(reset_default_tblspc); + + return true; +} + +static bool +_equalCreateStatsStmt(const CreateStatsStmt *a, const CreateStatsStmt *b) +{ + COMPARE_NODE_FIELD(defnames); + COMPARE_NODE_FIELD(stat_types); + COMPARE_NODE_FIELD(exprs); + COMPARE_NODE_FIELD(relations); + COMPARE_STRING_FIELD(stxcomment); + COMPARE_SCALAR_FIELD(if_not_exists); + + return true; +} + +static bool +_equalAlterStatsStmt(const AlterStatsStmt *a, const AlterStatsStmt *b) +{ + COMPARE_NODE_FIELD(defnames); + COMPARE_SCALAR_FIELD(stxstattarget); + COMPARE_SCALAR_FIELD(missing_ok); + + return true; +} + +static bool +_equalCreateFunctionStmt(const CreateFunctionStmt *a, const CreateFunctionStmt *b) +{ + COMPARE_SCALAR_FIELD(is_procedure); + COMPARE_SCALAR_FIELD(replace); + COMPARE_NODE_FIELD(funcname); + COMPARE_NODE_FIELD(parameters); + COMPARE_NODE_FIELD(returnType); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b) +{ + COMPARE_STRING_FIELD(name); + COMPARE_NODE_FIELD(argType); + COMPARE_SCALAR_FIELD(mode); + COMPARE_NODE_FIELD(defexpr); + + return true; +} + +static bool +_equalAlterFunctionStmt(const AlterFunctionStmt *a, const AlterFunctionStmt *b) +{ + COMPARE_SCALAR_FIELD(objtype); + COMPARE_NODE_FIELD(func); + COMPARE_NODE_FIELD(actions); + + return true; +} + +static bool +_equalDoStmt(const DoStmt *a, const DoStmt *b) +{ + COMPARE_NODE_FIELD(args); + + return true; +} + +static bool +_equalRenameStmt(const RenameStmt *a, const RenameStmt *b) +{ + COMPARE_SCALAR_FIELD(renameType); + COMPARE_SCALAR_FIELD(relationType); + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(object); + COMPARE_STRING_FIELD(subname); + COMPARE_STRING_FIELD(newname); + COMPARE_SCALAR_FIELD(behavior); + COMPARE_SCALAR_FIELD(missing_ok); + + return true; +} + +static bool +_equalAlterObjectDependsStmt(const AlterObjectDependsStmt *a, const AlterObjectDependsStmt *b) +{ + COMPARE_SCALAR_FIELD(objectType); + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(object); + COMPARE_NODE_FIELD(extname); + COMPARE_SCALAR_FIELD(remove); + + return true; +} + +static bool +_equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b) +{ + COMPARE_SCALAR_FIELD(objectType); + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(object); + COMPARE_STRING_FIELD(newschema); + COMPARE_SCALAR_FIELD(missing_ok); + + return true; +} + +static bool +_equalAlterOwnerStmt(const AlterOwnerStmt *a, const AlterOwnerStmt *b) +{ + COMPARE_SCALAR_FIELD(objectType); + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(object); + COMPARE_NODE_FIELD(newowner); + + return true; +} + +static bool +_equalAlterOperatorStmt(const AlterOperatorStmt *a, const AlterOperatorStmt *b) +{ + COMPARE_NODE_FIELD(opername); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterTypeStmt(const AlterTypeStmt *a, const AlterTypeStmt *b) +{ + COMPARE_NODE_FIELD(typeName); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalRuleStmt(const RuleStmt *a, const 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(const NotifyStmt *a, const NotifyStmt *b) +{ + COMPARE_STRING_FIELD(conditionname); + COMPARE_STRING_FIELD(payload); + + return true; +} + +static bool +_equalListenStmt(const ListenStmt *a, const ListenStmt *b) +{ + COMPARE_STRING_FIELD(conditionname); + + return true; +} + +static bool +_equalUnlistenStmt(const UnlistenStmt *a, const UnlistenStmt *b) +{ + COMPARE_STRING_FIELD(conditionname); + + return true; +} + +static bool +_equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b) +{ + COMPARE_SCALAR_FIELD(kind); + COMPARE_NODE_FIELD(options); + COMPARE_STRING_FIELD(savepoint_name); + COMPARE_STRING_FIELD(gid); + COMPARE_SCALAR_FIELD(chain); + + return true; +} + +static bool +_equalCompositeTypeStmt(const CompositeTypeStmt *a, const CompositeTypeStmt *b) +{ + COMPARE_NODE_FIELD(typevar); + COMPARE_NODE_FIELD(coldeflist); + + return true; +} + +static bool +_equalCreateEnumStmt(const CreateEnumStmt *a, const CreateEnumStmt *b) +{ + COMPARE_NODE_FIELD(typeName); + COMPARE_NODE_FIELD(vals); + + return true; +} + +static bool +_equalCreateRangeStmt(const CreateRangeStmt *a, const CreateRangeStmt *b) +{ + COMPARE_NODE_FIELD(typeName); + COMPARE_NODE_FIELD(params); + + return true; +} + +static bool +_equalAlterEnumStmt(const AlterEnumStmt *a, const AlterEnumStmt *b) +{ + COMPARE_NODE_FIELD(typeName); + COMPARE_STRING_FIELD(oldVal); + COMPARE_STRING_FIELD(newVal); + COMPARE_STRING_FIELD(newValNeighbor); + COMPARE_SCALAR_FIELD(newValIsAfter); + COMPARE_SCALAR_FIELD(skipIfNewValExists); + + return true; +} + +static bool +_equalViewStmt(const ViewStmt *a, const ViewStmt *b) +{ + COMPARE_NODE_FIELD(view); + COMPARE_NODE_FIELD(aliases); + COMPARE_NODE_FIELD(query); + COMPARE_SCALAR_FIELD(replace); + COMPARE_NODE_FIELD(options); + COMPARE_SCALAR_FIELD(withCheckOption); + + return true; +} + +static bool +_equalLoadStmt(const LoadStmt *a, const LoadStmt *b) +{ + COMPARE_STRING_FIELD(filename); + + return true; +} + +static bool +_equalCreateDomainStmt(const CreateDomainStmt *a, const CreateDomainStmt *b) +{ + COMPARE_NODE_FIELD(domainname); + COMPARE_NODE_FIELD(typeName); + COMPARE_NODE_FIELD(collClause); + COMPARE_NODE_FIELD(constraints); + + return true; +} + +static bool +_equalCreateOpClassStmt(const CreateOpClassStmt *a, const 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(const CreateOpClassItem *a, const CreateOpClassItem *b) +{ + COMPARE_SCALAR_FIELD(itemtype); + COMPARE_NODE_FIELD(name); + COMPARE_SCALAR_FIELD(number); + COMPARE_NODE_FIELD(order_family); + COMPARE_NODE_FIELD(class_args); + COMPARE_NODE_FIELD(storedtype); + + return true; +} + +static bool +_equalCreateOpFamilyStmt(const CreateOpFamilyStmt *a, const CreateOpFamilyStmt *b) +{ + COMPARE_NODE_FIELD(opfamilyname); + COMPARE_STRING_FIELD(amname); + + return true; +} + +static bool +_equalAlterOpFamilyStmt(const AlterOpFamilyStmt *a, const AlterOpFamilyStmt *b) +{ + COMPARE_NODE_FIELD(opfamilyname); + COMPARE_STRING_FIELD(amname); + COMPARE_SCALAR_FIELD(isDrop); + COMPARE_NODE_FIELD(items); + + return true; +} + +static bool +_equalCreatedbStmt(const CreatedbStmt *a, const CreatedbStmt *b) +{ + COMPARE_STRING_FIELD(dbname); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterDatabaseStmt(const AlterDatabaseStmt *a, const AlterDatabaseStmt *b) +{ + COMPARE_STRING_FIELD(dbname); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterDatabaseSetStmt(const AlterDatabaseSetStmt *a, const AlterDatabaseSetStmt *b) +{ + COMPARE_STRING_FIELD(dbname); + COMPARE_NODE_FIELD(setstmt); + + return true; +} + +static bool +_equalDropdbStmt(const DropdbStmt *a, const DropdbStmt *b) +{ + COMPARE_STRING_FIELD(dbname); + COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b) +{ + COMPARE_NODE_FIELD(options); + COMPARE_NODE_FIELD(rels); + COMPARE_SCALAR_FIELD(is_vacuumcmd); + + return true; +} + +static bool +_equalVacuumRelation(const VacuumRelation *a, const VacuumRelation *b) +{ + COMPARE_NODE_FIELD(relation); + COMPARE_SCALAR_FIELD(oid); + COMPARE_NODE_FIELD(va_cols); + + return true; +} + +static bool +_equalExplainStmt(const ExplainStmt *a, const ExplainStmt *b) +{ + COMPARE_NODE_FIELD(query); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalCreateTableAsStmt(const CreateTableAsStmt *a, const CreateTableAsStmt *b) +{ + COMPARE_NODE_FIELD(query); + COMPARE_NODE_FIELD(into); + COMPARE_SCALAR_FIELD(relkind); + COMPARE_SCALAR_FIELD(is_select_into); + COMPARE_SCALAR_FIELD(if_not_exists); + + return true; +} + +static bool +_equalRefreshMatViewStmt(const RefreshMatViewStmt *a, const RefreshMatViewStmt *b) +{ + COMPARE_SCALAR_FIELD(concurrent); + COMPARE_SCALAR_FIELD(skipData); + COMPARE_NODE_FIELD(relation); + + return true; +} + +static bool +_equalReplicaIdentityStmt(const ReplicaIdentityStmt *a, const ReplicaIdentityStmt *b) +{ + COMPARE_SCALAR_FIELD(identity_type); + COMPARE_STRING_FIELD(name); + + return true; +} + +static bool +_equalAlterSystemStmt(const AlterSystemStmt *a, const AlterSystemStmt *b) +{ + COMPARE_NODE_FIELD(setstmt); + + return true; +} + + +static bool +_equalCreateSeqStmt(const CreateSeqStmt *a, const CreateSeqStmt *b) +{ + COMPARE_NODE_FIELD(sequence); + COMPARE_NODE_FIELD(options); + COMPARE_SCALAR_FIELD(ownerId); + COMPARE_SCALAR_FIELD(for_identity); + COMPARE_SCALAR_FIELD(if_not_exists); + + return true; +} + +static bool +_equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b) +{ + COMPARE_NODE_FIELD(sequence); + COMPARE_NODE_FIELD(options); + COMPARE_SCALAR_FIELD(for_identity); + COMPARE_SCALAR_FIELD(missing_ok); + + return true; +} + +static bool +_equalVariableSetStmt(const VariableSetStmt *a, const VariableSetStmt *b) +{ + COMPARE_SCALAR_FIELD(kind); + COMPARE_STRING_FIELD(name); + COMPARE_NODE_FIELD(args); + COMPARE_SCALAR_FIELD(is_local); + + return true; +} + +static bool +_equalVariableShowStmt(const VariableShowStmt *a, const VariableShowStmt *b) +{ + COMPARE_STRING_FIELD(name); + + return true; +} + +static bool +_equalDiscardStmt(const DiscardStmt *a, const DiscardStmt *b) +{ + COMPARE_SCALAR_FIELD(target); + + return true; +} + +static bool +_equalCreateTableSpaceStmt(const CreateTableSpaceStmt *a, const CreateTableSpaceStmt *b) +{ + COMPARE_STRING_FIELD(tablespacename); + COMPARE_NODE_FIELD(owner); + COMPARE_STRING_FIELD(location); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalDropTableSpaceStmt(const DropTableSpaceStmt *a, const DropTableSpaceStmt *b) +{ + COMPARE_STRING_FIELD(tablespacename); + COMPARE_SCALAR_FIELD(missing_ok); + + return true; +} + +static bool +_equalAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *a, + const AlterTableSpaceOptionsStmt *b) +{ + COMPARE_STRING_FIELD(tablespacename); + COMPARE_NODE_FIELD(options); + COMPARE_SCALAR_FIELD(isReset); + + return true; +} + +static bool +_equalAlterTableMoveAllStmt(const AlterTableMoveAllStmt *a, + const AlterTableMoveAllStmt *b) +{ + COMPARE_STRING_FIELD(orig_tablespacename); + COMPARE_SCALAR_FIELD(objtype); + COMPARE_NODE_FIELD(roles); + COMPARE_STRING_FIELD(new_tablespacename); + COMPARE_SCALAR_FIELD(nowait); + + return true; +} + +static bool +_equalCreateExtensionStmt(const CreateExtensionStmt *a, const CreateExtensionStmt *b) +{ + COMPARE_STRING_FIELD(extname); + COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterExtensionStmt(const AlterExtensionStmt *a, const AlterExtensionStmt *b) +{ + COMPARE_STRING_FIELD(extname); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterExtensionContentsStmt(const AlterExtensionContentsStmt *a, const AlterExtensionContentsStmt *b) +{ + COMPARE_STRING_FIELD(extname); + COMPARE_SCALAR_FIELD(action); + COMPARE_SCALAR_FIELD(objtype); + COMPARE_NODE_FIELD(object); + + return true; +} + +static bool +_equalCreateFdwStmt(const CreateFdwStmt *a, const CreateFdwStmt *b) +{ + COMPARE_STRING_FIELD(fdwname); + COMPARE_NODE_FIELD(func_options); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterFdwStmt(const AlterFdwStmt *a, const AlterFdwStmt *b) +{ + COMPARE_STRING_FIELD(fdwname); + COMPARE_NODE_FIELD(func_options); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalCreateForeignServerStmt(const CreateForeignServerStmt *a, const CreateForeignServerStmt *b) +{ + COMPARE_STRING_FIELD(servername); + COMPARE_STRING_FIELD(servertype); + COMPARE_STRING_FIELD(version); + COMPARE_STRING_FIELD(fdwname); + COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterForeignServerStmt(const AlterForeignServerStmt *a, const AlterForeignServerStmt *b) +{ + COMPARE_STRING_FIELD(servername); + COMPARE_STRING_FIELD(version); + COMPARE_NODE_FIELD(options); + COMPARE_SCALAR_FIELD(has_version); + + return true; +} + +static bool +_equalCreateUserMappingStmt(const CreateUserMappingStmt *a, const CreateUserMappingStmt *b) +{ + COMPARE_NODE_FIELD(user); + COMPARE_STRING_FIELD(servername); + COMPARE_SCALAR_FIELD(if_not_exists); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterUserMappingStmt(const AlterUserMappingStmt *a, const AlterUserMappingStmt *b) +{ + COMPARE_NODE_FIELD(user); + COMPARE_STRING_FIELD(servername); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStmt *b) +{ + COMPARE_NODE_FIELD(user); + COMPARE_STRING_FIELD(servername); + COMPARE_SCALAR_FIELD(missing_ok); + + return true; +} + +static bool +_equalCreateForeignTableStmt(const CreateForeignTableStmt *a, const CreateForeignTableStmt *b) +{ + if (!_equalCreateStmt(&a->base, &b->base)) + return false; + + COMPARE_STRING_FIELD(servername); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalImportForeignSchemaStmt(const ImportForeignSchemaStmt *a, const ImportForeignSchemaStmt *b) +{ + COMPARE_STRING_FIELD(server_name); + COMPARE_STRING_FIELD(remote_schema); + COMPARE_STRING_FIELD(local_schema); + COMPARE_SCALAR_FIELD(list_type); + COMPARE_NODE_FIELD(table_list); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalCreateTransformStmt(const CreateTransformStmt *a, const CreateTransformStmt *b) +{ + COMPARE_SCALAR_FIELD(replace); + COMPARE_NODE_FIELD(type_name); + COMPARE_STRING_FIELD(lang); + COMPARE_NODE_FIELD(fromsql); + COMPARE_NODE_FIELD(tosql); + + return true; +} + +static bool +_equalCreateAmStmt(const CreateAmStmt *a, const CreateAmStmt *b) +{ + COMPARE_STRING_FIELD(amname); + COMPARE_NODE_FIELD(handler_name); + COMPARE_SCALAR_FIELD(amtype); + + return true; +} + +static bool +_equalCreateTrigStmt(const CreateTrigStmt *a, const CreateTrigStmt *b) +{ + COMPARE_STRING_FIELD(trigname); + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(funcname); + COMPARE_NODE_FIELD(args); + COMPARE_SCALAR_FIELD(row); + COMPARE_SCALAR_FIELD(timing); + COMPARE_SCALAR_FIELD(events); + COMPARE_NODE_FIELD(columns); + COMPARE_NODE_FIELD(whenClause); + COMPARE_SCALAR_FIELD(isconstraint); + COMPARE_NODE_FIELD(transitionRels); + COMPARE_SCALAR_FIELD(deferrable); + COMPARE_SCALAR_FIELD(initdeferred); + COMPARE_NODE_FIELD(constrrel); + + return true; +} + +static bool +_equalCreateEventTrigStmt(const CreateEventTrigStmt *a, const CreateEventTrigStmt *b) +{ + COMPARE_STRING_FIELD(trigname); + COMPARE_STRING_FIELD(eventname); + COMPARE_NODE_FIELD(whenclause); + COMPARE_NODE_FIELD(funcname); + + return true; +} + +static bool +_equalAlterEventTrigStmt(const AlterEventTrigStmt *a, const AlterEventTrigStmt *b) +{ + COMPARE_STRING_FIELD(trigname); + COMPARE_SCALAR_FIELD(tgenabled); + + return true; +} + +static bool +_equalCreatePLangStmt(const CreatePLangStmt *a, const CreatePLangStmt *b) +{ + COMPARE_SCALAR_FIELD(replace); + COMPARE_STRING_FIELD(plname); + COMPARE_NODE_FIELD(plhandler); + COMPARE_NODE_FIELD(plinline); + COMPARE_NODE_FIELD(plvalidator); + COMPARE_SCALAR_FIELD(pltrusted); + + return true; +} + +static bool +_equalCreateRoleStmt(const CreateRoleStmt *a, const CreateRoleStmt *b) +{ + COMPARE_SCALAR_FIELD(stmt_type); + COMPARE_STRING_FIELD(role); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterRoleStmt(const AlterRoleStmt *a, const AlterRoleStmt *b) +{ + COMPARE_NODE_FIELD(role); + COMPARE_NODE_FIELD(options); + COMPARE_SCALAR_FIELD(action); + + return true; +} + +static bool +_equalAlterRoleSetStmt(const AlterRoleSetStmt *a, const AlterRoleSetStmt *b) +{ + COMPARE_NODE_FIELD(role); + COMPARE_STRING_FIELD(database); + COMPARE_NODE_FIELD(setstmt); + + return true; +} + +static bool +_equalDropRoleStmt(const DropRoleStmt *a, const DropRoleStmt *b) +{ + COMPARE_NODE_FIELD(roles); + COMPARE_SCALAR_FIELD(missing_ok); + + return true; +} + +static bool +_equalLockStmt(const LockStmt *a, const LockStmt *b) +{ + COMPARE_NODE_FIELD(relations); + COMPARE_SCALAR_FIELD(mode); + COMPARE_SCALAR_FIELD(nowait); + + return true; +} + +static bool +_equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt *b) +{ + COMPARE_NODE_FIELD(constraints); + COMPARE_SCALAR_FIELD(deferred); + + return true; +} + +static bool +_equalReindexStmt(const ReindexStmt *a, const ReindexStmt *b) +{ + COMPARE_SCALAR_FIELD(kind); + COMPARE_NODE_FIELD(relation); + COMPARE_STRING_FIELD(name); + COMPARE_SCALAR_FIELD(options); + COMPARE_SCALAR_FIELD(concurrent); + + return true; +} + +static bool +_equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b) +{ + COMPARE_STRING_FIELD(schemaname); + COMPARE_NODE_FIELD(authrole); + COMPARE_NODE_FIELD(schemaElts); + COMPARE_SCALAR_FIELD(if_not_exists); + + return true; +} + +static bool +_equalCreateConversionStmt(const CreateConversionStmt *a, const 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(const CreateCastStmt *a, const 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 +_equalPrepareStmt(const PrepareStmt *a, const PrepareStmt *b) +{ + COMPARE_STRING_FIELD(name); + COMPARE_NODE_FIELD(argtypes); + COMPARE_NODE_FIELD(query); + + return true; +} + +static bool +_equalExecuteStmt(const ExecuteStmt *a, const ExecuteStmt *b) +{ + COMPARE_STRING_FIELD(name); + COMPARE_NODE_FIELD(params); + + return true; +} + +static bool +_equalDeallocateStmt(const DeallocateStmt *a, const DeallocateStmt *b) +{ + COMPARE_STRING_FIELD(name); + + return true; +} + +static bool +_equalDropOwnedStmt(const DropOwnedStmt *a, const DropOwnedStmt *b) +{ + COMPARE_NODE_FIELD(roles); + COMPARE_SCALAR_FIELD(behavior); + + return true; +} + +static bool +_equalReassignOwnedStmt(const ReassignOwnedStmt *a, const ReassignOwnedStmt *b) +{ + COMPARE_NODE_FIELD(roles); + COMPARE_NODE_FIELD(newrole); + + return true; +} + +static bool +_equalAlterTSDictionaryStmt(const AlterTSDictionaryStmt *a, const AlterTSDictionaryStmt *b) +{ + COMPARE_NODE_FIELD(dictname); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt *a, + const AlterTSConfigurationStmt *b) +{ + COMPARE_SCALAR_FIELD(kind); + 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 +_equalCreatePublicationStmt(const CreatePublicationStmt *a, + const CreatePublicationStmt *b) +{ + COMPARE_STRING_FIELD(pubname); + COMPARE_NODE_FIELD(options); + COMPARE_NODE_FIELD(tables); + COMPARE_SCALAR_FIELD(for_all_tables); + + return true; +} + +static bool +_equalAlterPublicationStmt(const AlterPublicationStmt *a, + const AlterPublicationStmt *b) +{ + COMPARE_STRING_FIELD(pubname); + COMPARE_NODE_FIELD(options); + COMPARE_NODE_FIELD(tables); + COMPARE_SCALAR_FIELD(for_all_tables); + COMPARE_SCALAR_FIELD(tableAction); + + return true; +} + +static bool +_equalCreateSubscriptionStmt(const CreateSubscriptionStmt *a, + const CreateSubscriptionStmt *b) +{ + COMPARE_STRING_FIELD(subname); + COMPARE_STRING_FIELD(conninfo); + COMPARE_NODE_FIELD(publication); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalAlterSubscriptionStmt(const AlterSubscriptionStmt *a, + const AlterSubscriptionStmt *b) +{ + COMPARE_SCALAR_FIELD(kind); + COMPARE_STRING_FIELD(subname); + COMPARE_STRING_FIELD(conninfo); + COMPARE_NODE_FIELD(publication); + COMPARE_NODE_FIELD(options); + + return true; +} + +static bool +_equalDropSubscriptionStmt(const DropSubscriptionStmt *a, + const DropSubscriptionStmt *b) +{ + COMPARE_STRING_FIELD(subname); + COMPARE_SCALAR_FIELD(missing_ok); + COMPARE_SCALAR_FIELD(behavior); + + return true; +} + +static bool +_equalCreatePolicyStmt(const CreatePolicyStmt *a, const CreatePolicyStmt *b) +{ + COMPARE_STRING_FIELD(policy_name); + COMPARE_NODE_FIELD(table); + COMPARE_STRING_FIELD(cmd_name); + COMPARE_SCALAR_FIELD(permissive); + COMPARE_NODE_FIELD(roles); + COMPARE_NODE_FIELD(qual); + COMPARE_NODE_FIELD(with_check); + + return true; +} + +static bool +_equalAlterPolicyStmt(const AlterPolicyStmt *a, const AlterPolicyStmt *b) +{ + COMPARE_STRING_FIELD(policy_name); + COMPARE_NODE_FIELD(table); + COMPARE_NODE_FIELD(roles); + COMPARE_NODE_FIELD(qual); + COMPARE_NODE_FIELD(with_check); + + return true; +} + +static bool +_equalAExpr(const A_Expr *a, const 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(const ColumnRef *a, const ColumnRef *b) +{ + COMPARE_NODE_FIELD(fields); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalParamRef(const ParamRef *a, const ParamRef *b) +{ + COMPARE_SCALAR_FIELD(number); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalAConst(const A_Const *a, const 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(const FuncCall *a, const FuncCall *b) +{ + COMPARE_NODE_FIELD(funcname); + COMPARE_NODE_FIELD(args); + COMPARE_NODE_FIELD(agg_order); + COMPARE_NODE_FIELD(agg_filter); + COMPARE_SCALAR_FIELD(agg_within_group); + 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(const A_Star *a, const A_Star *b) +{ + return true; +} + +static bool +_equalAIndices(const A_Indices *a, const A_Indices *b) +{ + COMPARE_SCALAR_FIELD(is_slice); + COMPARE_NODE_FIELD(lidx); + COMPARE_NODE_FIELD(uidx); + + return true; +} + +static bool +_equalA_Indirection(const A_Indirection *a, const A_Indirection *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_NODE_FIELD(indirection); + + return true; +} + +static bool +_equalA_ArrayExpr(const A_ArrayExpr *a, const A_ArrayExpr *b) +{ + COMPARE_NODE_FIELD(elements); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalResTarget(const ResTarget *a, const ResTarget *b) +{ + COMPARE_STRING_FIELD(name); + COMPARE_NODE_FIELD(indirection); + COMPARE_NODE_FIELD(val); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalMultiAssignRef(const MultiAssignRef *a, const MultiAssignRef *b) +{ + COMPARE_NODE_FIELD(source); + COMPARE_SCALAR_FIELD(colno); + COMPARE_SCALAR_FIELD(ncolumns); + + return true; +} + +static bool +_equalTypeName(const TypeName *a, const TypeName *b) +{ + COMPARE_NODE_FIELD(names); + COMPARE_SCALAR_FIELD(typeOid); + 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(const TypeCast *a, const TypeCast *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_NODE_FIELD(typeName); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalCollateClause(const CollateClause *a, const CollateClause *b) +{ + COMPARE_NODE_FIELD(arg); + COMPARE_NODE_FIELD(collname); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalSortBy(const SortBy *a, const 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(const WindowDef *a, const WindowDef *b) +{ + COMPARE_STRING_FIELD(name); + COMPARE_STRING_FIELD(refname); + COMPARE_NODE_FIELD(partitionClause); + COMPARE_NODE_FIELD(orderClause); + COMPARE_SCALAR_FIELD(frameOptions); + COMPARE_NODE_FIELD(startOffset); + COMPARE_NODE_FIELD(endOffset); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b) +{ + COMPARE_SCALAR_FIELD(lateral); + COMPARE_NODE_FIELD(subquery); + COMPARE_NODE_FIELD(alias); + + return true; +} + +static bool +_equalRangeFunction(const RangeFunction *a, const RangeFunction *b) +{ + COMPARE_SCALAR_FIELD(lateral); + COMPARE_SCALAR_FIELD(ordinality); + COMPARE_SCALAR_FIELD(is_rowsfrom); + COMPARE_NODE_FIELD(functions); + COMPARE_NODE_FIELD(alias); + COMPARE_NODE_FIELD(coldeflist); + + return true; +} + +static bool +_equalRangeTableSample(const RangeTableSample *a, const RangeTableSample *b) +{ + COMPARE_NODE_FIELD(relation); + COMPARE_NODE_FIELD(method); + COMPARE_NODE_FIELD(args); + COMPARE_NODE_FIELD(repeatable); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalRangeTableFunc(const RangeTableFunc *a, const RangeTableFunc *b) +{ + COMPARE_SCALAR_FIELD(lateral); + COMPARE_NODE_FIELD(docexpr); + COMPARE_NODE_FIELD(rowexpr); + COMPARE_NODE_FIELD(namespaces); + COMPARE_NODE_FIELD(columns); + COMPARE_NODE_FIELD(alias); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalRangeTableFuncCol(const RangeTableFuncCol *a, const RangeTableFuncCol *b) +{ + COMPARE_STRING_FIELD(colname); + COMPARE_NODE_FIELD(typeName); + COMPARE_SCALAR_FIELD(for_ordinality); + COMPARE_SCALAR_FIELD(is_not_null); + COMPARE_NODE_FIELD(colexpr); + COMPARE_NODE_FIELD(coldefexpr); + COMPARE_LOCATION_FIELD(location); + + return true; +} + + +static bool +_equalIndexElem(const IndexElem *a, const IndexElem *b) +{ + COMPARE_STRING_FIELD(name); + COMPARE_NODE_FIELD(expr); + COMPARE_STRING_FIELD(indexcolname); + COMPARE_NODE_FIELD(collation); + COMPARE_NODE_FIELD(opclass); + COMPARE_NODE_FIELD(opclassopts); + COMPARE_SCALAR_FIELD(ordering); + COMPARE_SCALAR_FIELD(nulls_ordering); + + return true; +} + +static bool +_equalColumnDef(const ColumnDef *a, const 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_SCALAR_FIELD(is_from_type); + COMPARE_SCALAR_FIELD(storage); + COMPARE_NODE_FIELD(raw_default); + COMPARE_NODE_FIELD(cooked_default); + COMPARE_SCALAR_FIELD(identity); + COMPARE_NODE_FIELD(identitySequence); + COMPARE_SCALAR_FIELD(generated); + COMPARE_NODE_FIELD(collClause); + COMPARE_SCALAR_FIELD(collOid); + COMPARE_NODE_FIELD(constraints); + COMPARE_NODE_FIELD(fdwoptions); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalConstraint(const Constraint *a, const Constraint *b) +{ + COMPARE_SCALAR_FIELD(contype); + COMPARE_STRING_FIELD(conname); + COMPARE_SCALAR_FIELD(deferrable); + COMPARE_SCALAR_FIELD(initdeferred); + COMPARE_LOCATION_FIELD(location); + COMPARE_SCALAR_FIELD(is_no_inherit); + COMPARE_NODE_FIELD(raw_expr); + COMPARE_STRING_FIELD(cooked_expr); + COMPARE_SCALAR_FIELD(generated_when); + COMPARE_NODE_FIELD(keys); + COMPARE_NODE_FIELD(including); + COMPARE_NODE_FIELD(exclusions); + COMPARE_NODE_FIELD(options); + COMPARE_STRING_FIELD(indexname); + COMPARE_STRING_FIELD(indexspace); + COMPARE_SCALAR_FIELD(reset_default_tblspc); + COMPARE_STRING_FIELD(access_method); + COMPARE_NODE_FIELD(where_clause); + 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_NODE_FIELD(old_conpfeqop); + COMPARE_SCALAR_FIELD(old_pktable_oid); + COMPARE_SCALAR_FIELD(skip_validation); + COMPARE_SCALAR_FIELD(initially_valid); + + return true; +} + +static bool +_equalDefElem(const DefElem *a, const DefElem *b) +{ + COMPARE_STRING_FIELD(defnamespace); + COMPARE_STRING_FIELD(defname); + COMPARE_NODE_FIELD(arg); + COMPARE_SCALAR_FIELD(defaction); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalLockingClause(const LockingClause *a, const LockingClause *b) +{ + COMPARE_NODE_FIELD(lockedRels); + COMPARE_SCALAR_FIELD(strength); + COMPARE_SCALAR_FIELD(waitPolicy); + + return true; +} + +static bool +_equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b) +{ + COMPARE_SCALAR_FIELD(rtekind); + COMPARE_SCALAR_FIELD(relid); + COMPARE_SCALAR_FIELD(relkind); + COMPARE_SCALAR_FIELD(rellockmode); + COMPARE_NODE_FIELD(tablesample); + COMPARE_NODE_FIELD(subquery); + COMPARE_SCALAR_FIELD(security_barrier); + COMPARE_SCALAR_FIELD(jointype); + COMPARE_SCALAR_FIELD(joinmergedcols); + COMPARE_NODE_FIELD(joinaliasvars); + COMPARE_NODE_FIELD(joinleftcols); + COMPARE_NODE_FIELD(joinrightcols); + COMPARE_NODE_FIELD(functions); + COMPARE_SCALAR_FIELD(funcordinality); + COMPARE_NODE_FIELD(tablefunc); + COMPARE_NODE_FIELD(values_lists); + COMPARE_STRING_FIELD(ctename); + COMPARE_SCALAR_FIELD(ctelevelsup); + COMPARE_SCALAR_FIELD(self_reference); + COMPARE_NODE_FIELD(coltypes); + COMPARE_NODE_FIELD(coltypmods); + COMPARE_NODE_FIELD(colcollations); + COMPARE_STRING_FIELD(enrname); + COMPARE_SCALAR_FIELD(enrtuples); + COMPARE_NODE_FIELD(alias); + COMPARE_NODE_FIELD(eref); + COMPARE_SCALAR_FIELD(lateral); + COMPARE_SCALAR_FIELD(inh); + COMPARE_SCALAR_FIELD(inFromCl); + COMPARE_SCALAR_FIELD(requiredPerms); + COMPARE_SCALAR_FIELD(checkAsUser); + COMPARE_BITMAPSET_FIELD(selectedCols); + COMPARE_BITMAPSET_FIELD(insertedCols); + COMPARE_BITMAPSET_FIELD(updatedCols); + COMPARE_BITMAPSET_FIELD(extraUpdatedCols); + COMPARE_NODE_FIELD(securityQuals); + + return true; +} + +static bool +_equalRangeTblFunction(const RangeTblFunction *a, const RangeTblFunction *b) +{ + COMPARE_NODE_FIELD(funcexpr); + COMPARE_SCALAR_FIELD(funccolcount); + COMPARE_NODE_FIELD(funccolnames); + COMPARE_NODE_FIELD(funccoltypes); + COMPARE_NODE_FIELD(funccoltypmods); + COMPARE_NODE_FIELD(funccolcollations); + COMPARE_BITMAPSET_FIELD(funcparams); + + return true; +} + +static bool +_equalTableSampleClause(const TableSampleClause *a, const TableSampleClause *b) +{ + COMPARE_SCALAR_FIELD(tsmhandler); + COMPARE_NODE_FIELD(args); + COMPARE_NODE_FIELD(repeatable); + + return true; +} + +static bool +_equalWithCheckOption(const WithCheckOption *a, const WithCheckOption *b) +{ + COMPARE_SCALAR_FIELD(kind); + COMPARE_STRING_FIELD(relname); + COMPARE_STRING_FIELD(polname); + COMPARE_NODE_FIELD(qual); + COMPARE_SCALAR_FIELD(cascaded); + + return true; +} + +static bool +_equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b) +{ + COMPARE_SCALAR_FIELD(tleSortGroupRef); + COMPARE_SCALAR_FIELD(eqop); + COMPARE_SCALAR_FIELD(sortop); + COMPARE_SCALAR_FIELD(nulls_first); + COMPARE_SCALAR_FIELD(hashable); + + return true; +} + +static bool +_equalGroupingSet(const GroupingSet *a, const GroupingSet *b) +{ + COMPARE_SCALAR_FIELD(kind); + COMPARE_NODE_FIELD(content); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalWindowClause(const WindowClause *a, const WindowClause *b) +{ + COMPARE_STRING_FIELD(name); + COMPARE_STRING_FIELD(refname); + COMPARE_NODE_FIELD(partitionClause); + COMPARE_NODE_FIELD(orderClause); + COMPARE_SCALAR_FIELD(frameOptions); + COMPARE_NODE_FIELD(startOffset); + COMPARE_NODE_FIELD(endOffset); + COMPARE_SCALAR_FIELD(startInRangeFunc); + COMPARE_SCALAR_FIELD(endInRangeFunc); + COMPARE_SCALAR_FIELD(inRangeColl); + COMPARE_SCALAR_FIELD(inRangeAsc); + COMPARE_SCALAR_FIELD(inRangeNullsFirst); + COMPARE_SCALAR_FIELD(winref); + COMPARE_SCALAR_FIELD(copiedOrder); + + return true; +} + +static bool +_equalRowMarkClause(const RowMarkClause *a, const RowMarkClause *b) +{ + COMPARE_SCALAR_FIELD(rti); + COMPARE_SCALAR_FIELD(strength); + COMPARE_SCALAR_FIELD(waitPolicy); + COMPARE_SCALAR_FIELD(pushedDown); + + return true; +} + +static bool +_equalWithClause(const WithClause *a, const WithClause *b) +{ + COMPARE_NODE_FIELD(ctes); + COMPARE_SCALAR_FIELD(recursive); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalInferClause(const InferClause *a, const InferClause *b) +{ + COMPARE_NODE_FIELD(indexElems); + COMPARE_NODE_FIELD(whereClause); + COMPARE_STRING_FIELD(conname); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalOnConflictClause(const OnConflictClause *a, const OnConflictClause *b) +{ + COMPARE_SCALAR_FIELD(action); + COMPARE_NODE_FIELD(infer); + COMPARE_NODE_FIELD(targetList); + COMPARE_NODE_FIELD(whereClause); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b) +{ + COMPARE_STRING_FIELD(ctename); + COMPARE_NODE_FIELD(aliascolnames); + COMPARE_SCALAR_FIELD(ctematerialized); + 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); + COMPARE_NODE_FIELD(ctecolcollations); + + return true; +} + +static bool +_equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b) +{ + COMPARE_SCALAR_FIELD(xmloption); + COMPARE_NODE_FIELD(expr); + COMPARE_NODE_FIELD(typeName); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalRoleSpec(const RoleSpec *a, const RoleSpec *b) +{ + COMPARE_SCALAR_FIELD(roletype); + COMPARE_STRING_FIELD(rolename); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalTriggerTransition(const TriggerTransition *a, const TriggerTransition *b) +{ + COMPARE_STRING_FIELD(name); + COMPARE_SCALAR_FIELD(isNew); + COMPARE_SCALAR_FIELD(isTable); + + return true; +} + +static bool +_equalPartitionElem(const PartitionElem *a, const PartitionElem *b) +{ + COMPARE_STRING_FIELD(name); + COMPARE_NODE_FIELD(expr); + COMPARE_NODE_FIELD(collation); + COMPARE_NODE_FIELD(opclass); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalPartitionSpec(const PartitionSpec *a, const PartitionSpec *b) +{ + COMPARE_STRING_FIELD(strategy); + COMPARE_NODE_FIELD(partParams); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalPartitionBoundSpec(const PartitionBoundSpec *a, const PartitionBoundSpec *b) +{ + COMPARE_SCALAR_FIELD(strategy); + COMPARE_SCALAR_FIELD(is_default); + COMPARE_SCALAR_FIELD(modulus); + COMPARE_SCALAR_FIELD(remainder); + COMPARE_NODE_FIELD(listdatums); + COMPARE_NODE_FIELD(lowerdatums); + COMPARE_NODE_FIELD(upperdatums); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalPartitionRangeDatum(const PartitionRangeDatum *a, const PartitionRangeDatum *b) +{ + COMPARE_SCALAR_FIELD(kind); + COMPARE_NODE_FIELD(value); + COMPARE_LOCATION_FIELD(location); + + return true; +} + +static bool +_equalPartitionCmd(const PartitionCmd *a, const PartitionCmd *b) +{ + COMPARE_NODE_FIELD(name); + COMPARE_NODE_FIELD(bound); + + return true; +} + +/* + * Stuff from pg_list.h + */ + +static bool +_equalList(const List *a, const List *b) +{ + const ListCell *item_a; + const 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(const Value *a, const 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(const void *a, const 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; + + /* Guard against stack overflow due to overly complex expressions */ + check_stack_depth(); + + switch (nodeTag(a)) + { + /* + * PRIMITIVE NODES + */ + case T_Alias: + retval = _equalAlias(a, b); + break; + case T_RangeVar: + retval = _equalRangeVar(a, b); + break; + case T_TableFunc: + retval = _equalTableFunc(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_GroupingFunc: + retval = _equalGroupingFunc(a, b); + break; + case T_WindowFunc: + retval = _equalWindowFunc(a, b); + break; + case T_SubscriptingRef: + retval = _equalSubscriptingRef(a, b); + break; + case T_FuncExpr: + retval = _equalFuncExpr(a, b); + break; + case T_NamedArgExpr: + retval = _equalNamedArgExpr(a, b); + break; + case T_OpExpr: + retval = _equalOpExpr(a, b); + break; + case T_DistinctExpr: + retval = _equalDistinctExpr(a, b); + break; + case T_NullIfExpr: + retval = _equalNullIfExpr(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_CollateExpr: + retval = _equalCollateExpr(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_SQLValueFunction: + retval = _equalSQLValueFunction(a, b); + break; + case T_XmlExpr: + retval = _equalXmlExpr(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_NextValueExpr: + retval = _equalNextValueExpr(a, b); + break; + case T_InferenceElem: + retval = _equalInferenceElem(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_OnConflictExpr: + retval = _equalOnConflictExpr(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; + + /* + * EXTENSIBLE NODES + */ + case T_ExtensibleNode: + retval = _equalExtensibleNode(a, b); + break; + + /* + * PARSE NODES + */ + case T_Query: + retval = _equalQuery(a, b); + break; + case T_RawStmt: + retval = _equalRawStmt(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_AlterCollationStmt: + retval = _equalAlterCollationStmt(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_AlterDefaultPrivilegesStmt: + retval = _equalAlterDefaultPrivilegesStmt(a, b); + break; + case T_DeclareCursorStmt: + retval = _equalDeclareCursorStmt(a, b); + break; + case T_ClosePortalStmt: + retval = _equalClosePortalStmt(a, b); + break; + case T_CallStmt: + retval = _equalCallStmt(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_TableLikeClause: + retval = _equalTableLikeClause(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_SecLabelStmt: + retval = _equalSecLabelStmt(a, b); + break; + case T_FetchStmt: + retval = _equalFetchStmt(a, b); + break; + case T_IndexStmt: + retval = _equalIndexStmt(a, b); + break; + case T_CreateStatsStmt: + retval = _equalCreateStatsStmt(a, b); + break; + case T_AlterStatsStmt: + retval = _equalAlterStatsStmt(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_DoStmt: + retval = _equalDoStmt(a, b); + break; + case T_RenameStmt: + retval = _equalRenameStmt(a, b); + break; + case T_AlterObjectDependsStmt: + retval = _equalAlterObjectDependsStmt(a, b); + break; + case T_AlterObjectSchemaStmt: + retval = _equalAlterObjectSchemaStmt(a, b); + break; + case T_AlterOwnerStmt: + retval = _equalAlterOwnerStmt(a, b); + break; + case T_AlterOperatorStmt: + retval = _equalAlterOperatorStmt(a, b); + break; + case T_AlterTypeStmt: + retval = _equalAlterTypeStmt(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_CreateRangeStmt: + retval = _equalCreateRangeStmt(a, b); + break; + case T_AlterEnumStmt: + retval = _equalAlterEnumStmt(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_VacuumRelation: + retval = _equalVacuumRelation(a, b); + break; + case T_ExplainStmt: + retval = _equalExplainStmt(a, b); + break; + case T_CreateTableAsStmt: + retval = _equalCreateTableAsStmt(a, b); + break; + case T_RefreshMatViewStmt: + retval = _equalRefreshMatViewStmt(a, b); + break; + case T_ReplicaIdentityStmt: + retval = _equalReplicaIdentityStmt(a, b); + break; + case T_AlterSystemStmt: + retval = _equalAlterSystemStmt(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_AlterTableSpaceOptionsStmt: + retval = _equalAlterTableSpaceOptionsStmt(a, b); + break; + case T_AlterTableMoveAllStmt: + retval = _equalAlterTableMoveAllStmt(a, b); + break; + case T_CreateExtensionStmt: + retval = _equalCreateExtensionStmt(a, b); + break; + case T_AlterExtensionStmt: + retval = _equalAlterExtensionStmt(a, b); + break; + case T_AlterExtensionContentsStmt: + retval = _equalAlterExtensionContentsStmt(a, b); + break; + case T_CreateFdwStmt: + retval = _equalCreateFdwStmt(a, b); + break; + case T_AlterFdwStmt: + retval = _equalAlterFdwStmt(a, b); + break; + case T_CreateForeignServerStmt: + retval = _equalCreateForeignServerStmt(a, b); + break; + case T_AlterForeignServerStmt: + retval = _equalAlterForeignServerStmt(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_CreateForeignTableStmt: + retval = _equalCreateForeignTableStmt(a, b); + break; + case T_ImportForeignSchemaStmt: + retval = _equalImportForeignSchemaStmt(a, b); + break; + case T_CreateTransformStmt: + retval = _equalCreateTransformStmt(a, b); + break; + case T_CreateAmStmt: + retval = _equalCreateAmStmt(a, b); + break; + case T_CreateTrigStmt: + retval = _equalCreateTrigStmt(a, b); + break; + case T_CreateEventTrigStmt: + retval = _equalCreateEventTrigStmt(a, b); + break; + case T_AlterEventTrigStmt: + retval = _equalAlterEventTrigStmt(a, b); + break; + case T_CreatePLangStmt: + retval = _equalCreatePLangStmt(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_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_CreatePolicyStmt: + retval = _equalCreatePolicyStmt(a, b); + break; + case T_AlterPolicyStmt: + retval = _equalAlterPolicyStmt(a, b); + break; + case T_CreatePublicationStmt: + retval = _equalCreatePublicationStmt(a, b); + break; + case T_AlterPublicationStmt: + retval = _equalAlterPublicationStmt(a, b); + break; + case T_CreateSubscriptionStmt: + retval = _equalCreateSubscriptionStmt(a, b); + break; + case T_AlterSubscriptionStmt: + retval = _equalAlterSubscriptionStmt(a, b); + break; + case T_DropSubscriptionStmt: + retval = _equalDropSubscriptionStmt(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_MultiAssignRef: + retval = _equalMultiAssignRef(a, b); + break; + case T_TypeCast: + retval = _equalTypeCast(a, b); + break; + case T_CollateClause: + retval = _equalCollateClause(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_RangeTableSample: + retval = _equalRangeTableSample(a, b); + break; + case T_RangeTableFunc: + retval = _equalRangeTableFunc(a, b); + break; + case T_RangeTableFuncCol: + retval = _equalRangeTableFuncCol(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_RangeTblFunction: + retval = _equalRangeTblFunction(a, b); + break; + case T_TableSampleClause: + retval = _equalTableSampleClause(a, b); + break; + case T_WithCheckOption: + retval = _equalWithCheckOption(a, b); + break; + case T_SortGroupClause: + retval = _equalSortGroupClause(a, b); + break; + case T_GroupingSet: + retval = _equalGroupingSet(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_InferClause: + retval = _equalInferClause(a, b); + break; + case T_OnConflictClause: + retval = _equalOnConflictClause(a, b); + break; + case T_CommonTableExpr: + retval = _equalCommonTableExpr(a, b); + break; + case T_ObjectWithArgs: + retval = _equalObjectWithArgs(a, b); + break; + case T_AccessPriv: + retval = _equalAccessPriv(a, b); + break; + case T_XmlSerialize: + retval = _equalXmlSerialize(a, b); + break; + case T_RoleSpec: + retval = _equalRoleSpec(a, b); + break; + case T_TriggerTransition: + retval = _equalTriggerTransition(a, b); + break; + case T_PartitionElem: + retval = _equalPartitionElem(a, b); + break; + case T_PartitionSpec: + retval = _equalPartitionSpec(a, b); + break; + case T_PartitionBoundSpec: + retval = _equalPartitionBoundSpec(a, b); + break; + case T_PartitionRangeDatum: + retval = _equalPartitionRangeDatum(a, b); + break; + case T_PartitionCmd: + retval = _equalPartitionCmd(a, b); + break; + + default: + elog(ERROR, "unrecognized node type: %d", + (int) nodeTag(a)); + retval = false; /* keep compiler quiet */ + break; + } + + return retval; +} |