/src/backend/nodes/equalfuncs.c
C | 3113 lines | 2548 code | 421 blank | 144 comment | 54 complexity | 5e716be6d093c5cb1682b90e7e7d0ee6 MD5 | raw file
Possible License(s): AGPL-3.0
Large files files are truncated, but you can click here to view the full file
- /*-------------------------------------------------------------------------
- *
- * 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-2014, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * IDENTIFICATION
- * src/backend/nodes/equalfuncs.c
- *
- *-------------------------------------------------------------------------
- */
- #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)
- /* 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(inhOpt);
- COMPARE_SCALAR_FIELD(relpersistence);
- COMPARE_NODE_FIELD(alias);
- COMPARE_LOCATION_FIELD(location);
- return true;
- }
- static bool
- _equalIntoClause(const IntoClause *a, const IntoClause *b)
- {
- COMPARE_NODE_FIELD(rel);
- COMPARE_NODE_FIELD(colNames);
- 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);
- COMPARE_SCALAR_FIELD(varnoold);
- COMPARE_SCALAR_FIELD(varoattno);
- 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);
- 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_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
- _equalArrayRef(const ArrayRef *a, const ArrayRef *b)
- {
- COMPARE_SCALAR_FIELD(refarraytype);
- 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_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_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_SCALAR_FIELD(elemfuncid);
- COMPARE_SCALAR_FIELD(resulttype);
- COMPARE_SCALAR_FIELD(resulttypmod);
- COMPARE_SCALAR_FIELD(resultcollid);
- COMPARE_SCALAR_FIELD(isExplicit);
- 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
- _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);
- return true;
- }
- static bool
- _equalBooleanTest(const BooleanTest *a, const BooleanTest *b)
- {
- COMPARE_NODE_FIELD(arg);
- COMPARE_SCALAR_FIELD(booltesttype);
- 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
- _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;
- }
- /*
- * Stuff from relation.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_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_NODE_FIELD(join_quals);
- return true;
- }
- static bool
- _equalLateralJoinInfo(const LateralJoinInfo *a, const LateralJoinInfo *b)
- {
- COMPARE_BITMAPSET_FIELD(lateral_lhs);
- COMPARE_BITMAPSET_FIELD(lateral_rhs);
- 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(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 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(hasSubLinks);
- COMPARE_SCALAR_FIELD(hasDistinctOn);
- COMPARE_SCALAR_FIELD(hasRecursive);
- COMPARE_SCALAR_FIELD(hasModifyingCTE);
- COMPARE_SCALAR_FIELD(hasForUpdate);
- COMPARE_NODE_FIELD(cteList);
- COMPARE_NODE_FIELD(rtable);
- COMPARE_NODE_FIELD(jointree);
- COMPARE_NODE_FIELD(targetList);
- COMPARE_NODE_FIELD(withCheckOptions);
- 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);
- COMPARE_NODE_FIELD(constraintDeps);
- 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(returningList);
- COMPARE_NODE_FIELD(withClause);
- 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_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_NODE_FIELD(def);
- COMPARE_SCALAR_FIELD(behavior);
- COMPARE_SCALAR_FIELD(missing_ok);
- 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
- _equalPrivGrantee(const PrivGrantee *a, const PrivGrantee *b)
- {
- COMPARE_STRING_FIELD(rolname);
- return true;
- }
- static bool
- _equalFuncWithArgs(const FuncWithArgs *a, const FuncWithArgs *b)
- {
- COMPARE_NODE_FIELD(funcname);
- COMPARE_NODE_FIELD(funcargs);
- 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_STRING_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
- _equalClusterStmt(const ClusterStmt *a, const ClusterStmt *b)
- {
- COMPARE_NODE_FIELD(relation);
- COMPARE_STRING_FIELD(indexname);
- COMPARE_SCALAR_FIELD(verbose);
- 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);
- 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(ofTypename);
- COMPARE_NODE_FIELD(constraints);
- COMPARE_NODE_FIELD(options);
- COMPARE_SCALAR_FIELD(oncommit);
- COMPARE_STRING_FIELD(tablespacename);
- 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);
- 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);
- return true;
- }
- static bool
- _equalDropStmt(const DropStmt *a, const DropStmt *b)
- {
- COMPARE_NODE_FIELD(objects);
- COMPARE_NODE_FIELD(arguments);
- 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(objname);
- COMPARE_NODE_FIELD(objargs);
- COMPARE_STRING_FIELD(comment);
- return true;
- }
- static bool
- _equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b)
- {
- COMPARE_SCALAR_FIELD(objtype);
- COMPARE_NODE_FIELD(objname);
- COMPARE_NODE_FIELD(objargs);
- 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(options);
- COMPARE_NODE_FIELD(whereClause);
- COMPARE_NODE_FIELD(excludeOpNames);
- COMPARE_STRING_FIELD(idxcomment);
- COMPARE_SCALAR_FIELD(indexOid);
- COMPARE_SCALAR_FIELD(oldNode);
- COMPARE_SCALAR_FIELD(unique);
- COMPARE_SCALAR_FIELD(primary);
- COMPARE_SCALAR_FIELD(isconstraint);
- COMPARE_SCALAR_FIELD(deferrable);
- COMPARE_SCALAR_FIELD(initdeferred);
- COMPARE_SCALAR_FIELD(concurrent);
- return true;
- }
- static bool
- _equalCreateFunctionStmt(const CreateFunctionStmt *a, const 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(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_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_NODE_FIELD(objarg);
- COMPARE_STRING_FIELD(subname);
- COMPARE_STRING_FIELD(newname);
- COMPARE_SCALAR_FIELD(behavior);
- COMPARE_SCALAR_FIELD(missing_ok);
- return true;
- }
- static bool
- _equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b)
- {
- COMPARE_SCALAR_FIELD(objectType);
- COMPARE_NODE_FIELD(relation);
- COMPARE_NODE_FIELD(object);
- COMPARE_NODE_FIELD(objarg);
- 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(objarg);
- COMPARE_STRING_FIELD(newowner);
- 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(gid);
- 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(newVal);
- COMPARE_STRING_FIELD(newValNeighbor);
- COMPARE_SCALAR_FIELD(newValIsAfter);
- COMPARE_SCALAR_FIELD(skipIfExists);
- 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_NODE_FIELD(args);
- 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);
- return true;
- }
- static bool
- _equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b)
- {
- COMPARE_SCALAR_FIELD(options);
- COMPARE_SCALAR_FIELD(freeze_min_age);
- COMPARE_SCALAR_FIELD(freeze_table_age);
- COMPARE_SCALAR_FIELD(multixact_freeze_min_age);
- COMPARE_SCALAR_FIELD(multixact_freeze_table_age);
- COMPARE_NODE_FIELD(relation);
- 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);
- 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);
- return true;
- }
- static bool
- _equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b)
- {
- COMPARE_NODE_FIELD(sequence);
- COMPARE_NODE_FIELD(options);
- 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_STRING_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
- _equalAlterTableSpaceMoveStmt(const AlterTableSpaceMoveStmt *a,
- const AlterTableSpaceMoveStmt *b)
- {
- COMPARE_STRING_FIELD(orig_tablespacename);
- COMPARE_SCALAR_FIELD(objtype);
- COMPARE_SCALAR_FIELD(move_all);
- 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(objname);
- COMPARE_NODE_FIELD(objargs);
- 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_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_STRING_FIELD(username);
- COMPARE_STRING_FIELD(servername);
- COMPARE_NODE_FIELD(options);
- return true;
- }
- static bool
- _equalAlterUserMappingStmt(const AlterUserMappingStmt *a, const AlterUserMappingStmt *b)
- {
- COMPARE_STRING_FIELD(username);
- COMPARE_STRING_FIELD(servername);
- COMPARE_NODE_FIELD(options);
- return true;
- }
- static bool
- _equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStmt *b)
- {
- COMPARE_STRING_FIELD(username);
- 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
- _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_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_SCALAR_FIELD(eventname);
- COMPARE_NODE_FIELD(funcname);
- COMPARE_NODE_FIELD(whenclause);
- 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_STRING_FIELD(role);
- COMPARE_NODE_FIELD(options);
- COMPARE_SCALAR_FIELD(action);
- return true;
- }
- static bool
- _equalAlterRoleSetStmt(const AlterRoleSetStmt *a, const AlterRoleSetStmt *b)
- {
- COMPARE_STRING_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(do_system);
- COMPARE_SCALAR_FIELD(do_user);
- return true;
- }
- static bool
- _equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b)
- {
- COMPARE_STRING_FIELD(schemaname);
- COMPARE_STRING_FIELD(authid);
- 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_STRING_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_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(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_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
- _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
- _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_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_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 …
Large files files are truncated, but you can click here to view the full file