LCOV - code coverage report
Current view: top level - src/backend/nodes - equalfuncs.funcs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 1665 1741 95.6 %
Date: 2023-11-29 04:11:06 Functions: 246 255 96.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * equalfuncs.funcs.c
       4             :  *    Generated node infrastructure code
       5             :  *
       6             :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * NOTES
      10             :  *  ******************************
      11             :  *  *** DO NOT EDIT THIS FILE! ***
      12             :  *  ******************************
      13             :  *
      14             :  *  It has been GENERATED by src/backend/nodes/gen_node_support.pl
      15             :  *
      16             :  *-------------------------------------------------------------------------
      17             :  */
      18             : #include "access/amapi.h"
      19             : #include "access/sdir.h"
      20             : #include "access/tableam.h"
      21             : #include "access/tsmapi.h"
      22             : #include "commands/event_trigger.h"
      23             : #include "commands/trigger.h"
      24             : #include "executor/tuptable.h"
      25             : #include "foreign/fdwapi.h"
      26             : #include "nodes/bitmapset.h"
      27             : #include "nodes/execnodes.h"
      28             : #include "nodes/extensible.h"
      29             : #include "nodes/lockoptions.h"
      30             : #include "nodes/miscnodes.h"
      31             : #include "nodes/nodes.h"
      32             : #include "nodes/parsenodes.h"
      33             : #include "nodes/pathnodes.h"
      34             : #include "nodes/plannodes.h"
      35             : #include "nodes/primnodes.h"
      36             : #include "nodes/replnodes.h"
      37             : #include "nodes/supportnodes.h"
      38             : #include "nodes/value.h"
      39             : #include "utils/rel.h"
      40             : 
      41             : static bool
      42     2045462 : _equalAlias(const Alias *a, const Alias *b)
      43             : {
      44     2045462 :     COMPARE_STRING_FIELD(aliasname);
      45     2045462 :     COMPARE_NODE_FIELD(colnames);
      46             : 
      47     2045462 :     return true;
      48             : }
      49             : 
      50             : static bool
      51     1343798 : _equalRangeVar(const RangeVar *a, const RangeVar *b)
      52             : {
      53     1343798 :     COMPARE_STRING_FIELD(catalogname);
      54     1343798 :     COMPARE_STRING_FIELD(schemaname);
      55     1343762 :     COMPARE_STRING_FIELD(relname);
      56     1342958 :     COMPARE_SCALAR_FIELD(inh);
      57     1342958 :     COMPARE_SCALAR_FIELD(relpersistence);
      58     1342958 :     COMPARE_NODE_FIELD(alias);
      59             :     COMPARE_LOCATION_FIELD(location);
      60             : 
      61     1342958 :     return true;
      62             : }
      63             : 
      64             : static bool
      65         408 : _equalTableFunc(const TableFunc *a, const TableFunc *b)
      66             : {
      67         408 :     COMPARE_NODE_FIELD(ns_uris);
      68         408 :     COMPARE_NODE_FIELD(ns_names);
      69         408 :     COMPARE_NODE_FIELD(docexpr);
      70         408 :     COMPARE_NODE_FIELD(rowexpr);
      71         408 :     COMPARE_NODE_FIELD(colnames);
      72         408 :     COMPARE_NODE_FIELD(coltypes);
      73         408 :     COMPARE_NODE_FIELD(coltypmods);
      74         408 :     COMPARE_NODE_FIELD(colcollations);
      75         408 :     COMPARE_NODE_FIELD(colexprs);
      76         408 :     COMPARE_NODE_FIELD(coldefexprs);
      77         408 :     COMPARE_BITMAPSET_FIELD(notnulls);
      78         408 :     COMPARE_SCALAR_FIELD(ordinalitycol);
      79             :     COMPARE_LOCATION_FIELD(location);
      80             : 
      81         408 :     return true;
      82             : }
      83             : 
      84             : static bool
      85        7372 : _equalIntoClause(const IntoClause *a, const IntoClause *b)
      86             : {
      87        7372 :     COMPARE_NODE_FIELD(rel);
      88        7372 :     COMPARE_NODE_FIELD(colNames);
      89        7372 :     COMPARE_STRING_FIELD(accessMethod);
      90        7372 :     COMPARE_NODE_FIELD(options);
      91        7372 :     COMPARE_SCALAR_FIELD(onCommit);
      92        7372 :     COMPARE_STRING_FIELD(tableSpaceName);
      93        7372 :     COMPARE_NODE_FIELD(viewQuery);
      94        7372 :     COMPARE_SCALAR_FIELD(skipData);
      95             : 
      96        7372 :     return true;
      97             : }
      98             : 
      99             : static bool
     100    12849158 : _equalVar(const Var *a, const Var *b)
     101             : {
     102    12849158 :     COMPARE_SCALAR_FIELD(varno);
     103    10807770 :     COMPARE_SCALAR_FIELD(varattno);
     104     9924564 :     COMPARE_SCALAR_FIELD(vartype);
     105     9924564 :     COMPARE_SCALAR_FIELD(vartypmod);
     106     9924564 :     COMPARE_SCALAR_FIELD(varcollid);
     107     9924564 :     COMPARE_BITMAPSET_FIELD(varnullingrels);
     108     9910304 :     COMPARE_SCALAR_FIELD(varlevelsup);
     109             :     COMPARE_LOCATION_FIELD(location);
     110             : 
     111     9910298 :     return true;
     112             : }
     113             : 
     114             : static bool
     115      283880 : _equalParam(const Param *a, const Param *b)
     116             : {
     117      283880 :     COMPARE_SCALAR_FIELD(paramkind);
     118      281216 :     COMPARE_SCALAR_FIELD(paramid);
     119      270792 :     COMPARE_SCALAR_FIELD(paramtype);
     120      270792 :     COMPARE_SCALAR_FIELD(paramtypmod);
     121      270792 :     COMPARE_SCALAR_FIELD(paramcollid);
     122             :     COMPARE_LOCATION_FIELD(location);
     123             : 
     124      270792 :     return true;
     125             : }
     126             : 
     127             : static bool
     128       91564 : _equalAggref(const Aggref *a, const Aggref *b)
     129             : {
     130       91564 :     COMPARE_SCALAR_FIELD(aggfnoid);
     131       83006 :     COMPARE_SCALAR_FIELD(aggtype);
     132       82494 :     COMPARE_SCALAR_FIELD(aggcollid);
     133       82494 :     COMPARE_SCALAR_FIELD(inputcollid);
     134       82494 :     COMPARE_NODE_FIELD(aggargtypes);
     135       82494 :     COMPARE_NODE_FIELD(aggdirectargs);
     136       82494 :     COMPARE_NODE_FIELD(args);
     137       80902 :     COMPARE_NODE_FIELD(aggorder);
     138       80902 :     COMPARE_NODE_FIELD(aggdistinct);
     139       80902 :     COMPARE_NODE_FIELD(aggfilter);
     140       80884 :     COMPARE_SCALAR_FIELD(aggstar);
     141       80884 :     COMPARE_SCALAR_FIELD(aggvariadic);
     142       80884 :     COMPARE_SCALAR_FIELD(aggkind);
     143       80884 :     COMPARE_SCALAR_FIELD(agglevelsup);
     144       80884 :     COMPARE_SCALAR_FIELD(aggsplit);
     145       80848 :     COMPARE_SCALAR_FIELD(aggno);
     146       80848 :     COMPARE_SCALAR_FIELD(aggtransno);
     147             :     COMPARE_LOCATION_FIELD(location);
     148             : 
     149       80848 :     return true;
     150             : }
     151             : 
     152             : static bool
     153        1340 : _equalGroupingFunc(const GroupingFunc *a, const GroupingFunc *b)
     154             : {
     155        1340 :     COMPARE_NODE_FIELD(args);
     156        1340 :     COMPARE_SCALAR_FIELD(agglevelsup);
     157             :     COMPARE_LOCATION_FIELD(location);
     158             : 
     159        1340 :     return true;
     160             : }
     161             : 
     162             : static bool
     163        8568 : _equalWindowFunc(const WindowFunc *a, const WindowFunc *b)
     164             : {
     165        8568 :     COMPARE_SCALAR_FIELD(winfnoid);
     166        6714 :     COMPARE_SCALAR_FIELD(wintype);
     167        6714 :     COMPARE_SCALAR_FIELD(wincollid);
     168        6714 :     COMPARE_SCALAR_FIELD(inputcollid);
     169        6714 :     COMPARE_NODE_FIELD(args);
     170        6648 :     COMPARE_NODE_FIELD(aggfilter);
     171        6630 :     COMPARE_SCALAR_FIELD(winref);
     172        6582 :     COMPARE_SCALAR_FIELD(winstar);
     173        6582 :     COMPARE_SCALAR_FIELD(winagg);
     174             :     COMPARE_LOCATION_FIELD(location);
     175             : 
     176        6582 :     return true;
     177             : }
     178             : 
     179             : static bool
     180       18444 : _equalSubscriptingRef(const SubscriptingRef *a, const SubscriptingRef *b)
     181             : {
     182       18444 :     COMPARE_SCALAR_FIELD(refcontainertype);
     183       18444 :     COMPARE_SCALAR_FIELD(refelemtype);
     184       18444 :     COMPARE_SCALAR_FIELD(refrestype);
     185       18444 :     COMPARE_SCALAR_FIELD(reftypmod);
     186       18444 :     COMPARE_SCALAR_FIELD(refcollid);
     187       18444 :     COMPARE_NODE_FIELD(refupperindexpr);
     188       18336 :     COMPARE_NODE_FIELD(reflowerindexpr);
     189       18336 :     COMPARE_NODE_FIELD(refexpr);
     190       18096 :     COMPARE_NODE_FIELD(refassgnexpr);
     191             : 
     192       18096 :     return true;
     193             : }
     194             : 
     195             : static bool
     196      669008 : _equalFuncExpr(const FuncExpr *a, const FuncExpr *b)
     197             : {
     198      669008 :     COMPARE_SCALAR_FIELD(funcid);
     199      667054 :     COMPARE_SCALAR_FIELD(funcresulttype);
     200      666910 :     COMPARE_SCALAR_FIELD(funcretset);
     201      666910 :     COMPARE_SCALAR_FIELD(funcvariadic);
     202      666910 :     COMPARE_SCALAR_FIELD(funccollid);
     203      666910 :     COMPARE_SCALAR_FIELD(inputcollid);
     204      666910 :     COMPARE_NODE_FIELD(args);
     205             :     COMPARE_LOCATION_FIELD(location);
     206             : 
     207      664604 :     return true;
     208             : }
     209             : 
     210             : static bool
     211      195040 : _equalNamedArgExpr(const NamedArgExpr *a, const NamedArgExpr *b)
     212             : {
     213      195040 :     COMPARE_NODE_FIELD(arg);
     214      195040 :     COMPARE_STRING_FIELD(name);
     215      195040 :     COMPARE_SCALAR_FIELD(argnumber);
     216             :     COMPARE_LOCATION_FIELD(location);
     217             : 
     218      195040 :     return true;
     219             : }
     220             : 
     221             : static bool
     222     1153038 : _equalOpExpr(const OpExpr *a, const OpExpr *b)
     223             : {
     224     1153038 :     COMPARE_SCALAR_FIELD(opno);
     225     1060778 :     if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
     226           0 :         return false;
     227     1060778 :     COMPARE_SCALAR_FIELD(opresulttype);
     228     1060778 :     COMPARE_SCALAR_FIELD(opretset);
     229     1060778 :     COMPARE_SCALAR_FIELD(opcollid);
     230     1060778 :     COMPARE_SCALAR_FIELD(inputcollid);
     231     1060776 :     COMPARE_NODE_FIELD(args);
     232             :     COMPARE_LOCATION_FIELD(location);
     233             : 
     234      981658 :     return true;
     235             : }
     236             : 
     237             : static bool
     238        1492 : _equalDistinctExpr(const DistinctExpr *a, const DistinctExpr *b)
     239             : {
     240        1492 :     COMPARE_SCALAR_FIELD(opno);
     241        1492 :     if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
     242           0 :         return false;
     243        1492 :     COMPARE_SCALAR_FIELD(opresulttype);
     244        1492 :     COMPARE_SCALAR_FIELD(opretset);
     245        1492 :     COMPARE_SCALAR_FIELD(opcollid);
     246        1492 :     COMPARE_SCALAR_FIELD(inputcollid);
     247        1492 :     COMPARE_NODE_FIELD(args);
     248             :     COMPARE_LOCATION_FIELD(location);
     249             : 
     250        1492 :     return true;
     251             : }
     252             : 
     253             : static bool
     254         266 : _equalNullIfExpr(const NullIfExpr *a, const NullIfExpr *b)
     255             : {
     256         266 :     COMPARE_SCALAR_FIELD(opno);
     257         266 :     if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
     258           0 :         return false;
     259         266 :     COMPARE_SCALAR_FIELD(opresulttype);
     260         266 :     COMPARE_SCALAR_FIELD(opretset);
     261         266 :     COMPARE_SCALAR_FIELD(opcollid);
     262         266 :     COMPARE_SCALAR_FIELD(inputcollid);
     263         266 :     COMPARE_NODE_FIELD(args);
     264             :     COMPARE_LOCATION_FIELD(location);
     265             : 
     266         266 :     return true;
     267             : }
     268             : 
     269             : static bool
     270       49200 : _equalScalarArrayOpExpr(const ScalarArrayOpExpr *a, const ScalarArrayOpExpr *b)
     271             : {
     272       49200 :     COMPARE_SCALAR_FIELD(opno);
     273       48732 :     if (a->opfuncid != b->opfuncid && a->opfuncid != 0 && b->opfuncid != 0)
     274           0 :         return false;
     275       48732 :     if (a->hashfuncid != b->hashfuncid && a->hashfuncid != 0 && b->hashfuncid != 0)
     276           0 :         return false;
     277       48732 :     if (a->negfuncid != b->negfuncid && a->negfuncid != 0 && b->negfuncid != 0)
     278           0 :         return false;
     279       48732 :     COMPARE_SCALAR_FIELD(useOr);
     280       48732 :     COMPARE_SCALAR_FIELD(inputcollid);
     281       48732 :     COMPARE_NODE_FIELD(args);
     282             :     COMPARE_LOCATION_FIELD(location);
     283             : 
     284       48660 :     return true;
     285             : }
     286             : 
     287             : static bool
     288      496876 : _equalBoolExpr(const BoolExpr *a, const BoolExpr *b)
     289             : {
     290      496876 :     COMPARE_SCALAR_FIELD(boolop);
     291      496876 :     COMPARE_NODE_FIELD(args);
     292             :     COMPARE_LOCATION_FIELD(location);
     293             : 
     294      496674 :     return true;
     295             : }
     296             : 
     297             : static bool
     298      133862 : _equalSubLink(const SubLink *a, const SubLink *b)
     299             : {
     300      133862 :     COMPARE_SCALAR_FIELD(subLinkType);
     301      133862 :     COMPARE_SCALAR_FIELD(subLinkId);
     302      133862 :     COMPARE_NODE_FIELD(testexpr);
     303      133850 :     COMPARE_NODE_FIELD(operName);
     304      133850 :     COMPARE_NODE_FIELD(subselect);
     305             :     COMPARE_LOCATION_FIELD(location);
     306             : 
     307      133844 :     return true;
     308             : }
     309             : 
     310             : static bool
     311         216 : _equalSubPlan(const SubPlan *a, const SubPlan *b)
     312             : {
     313         216 :     COMPARE_SCALAR_FIELD(subLinkType);
     314         216 :     COMPARE_NODE_FIELD(testexpr);
     315         216 :     COMPARE_NODE_FIELD(paramIds);
     316         216 :     COMPARE_SCALAR_FIELD(plan_id);
     317          96 :     COMPARE_STRING_FIELD(plan_name);
     318          96 :     COMPARE_SCALAR_FIELD(firstColType);
     319          96 :     COMPARE_SCALAR_FIELD(firstColTypmod);
     320          96 :     COMPARE_SCALAR_FIELD(firstColCollation);
     321          96 :     COMPARE_SCALAR_FIELD(useHashTable);
     322          96 :     COMPARE_SCALAR_FIELD(unknownEqFalse);
     323          96 :     COMPARE_SCALAR_FIELD(parallel_safe);
     324          96 :     COMPARE_NODE_FIELD(setParam);
     325          96 :     COMPARE_NODE_FIELD(parParam);
     326          96 :     COMPARE_NODE_FIELD(args);
     327          96 :     COMPARE_SCALAR_FIELD(startup_cost);
     328          96 :     COMPARE_SCALAR_FIELD(per_call_cost);
     329             : 
     330          96 :     return true;
     331             : }
     332             : 
     333             : static bool
     334           0 : _equalAlternativeSubPlan(const AlternativeSubPlan *a, const AlternativeSubPlan *b)
     335             : {
     336           0 :     COMPARE_NODE_FIELD(subplans);
     337             : 
     338           0 :     return true;
     339             : }
     340             : 
     341             : static bool
     342        8166 : _equalFieldSelect(const FieldSelect *a, const FieldSelect *b)
     343             : {
     344        8166 :     COMPARE_NODE_FIELD(arg);
     345        8160 :     COMPARE_SCALAR_FIELD(fieldnum);
     346        8160 :     COMPARE_SCALAR_FIELD(resulttype);
     347        8160 :     COMPARE_SCALAR_FIELD(resulttypmod);
     348        8160 :     COMPARE_SCALAR_FIELD(resultcollid);
     349             : 
     350        8160 :     return true;
     351             : }
     352             : 
     353             : static bool
     354         572 : _equalFieldStore(const FieldStore *a, const FieldStore *b)
     355             : {
     356         572 :     COMPARE_NODE_FIELD(arg);
     357         572 :     COMPARE_NODE_FIELD(newvals);
     358         572 :     COMPARE_NODE_FIELD(fieldnums);
     359         572 :     COMPARE_SCALAR_FIELD(resulttype);
     360             : 
     361         572 :     return true;
     362             : }
     363             : 
     364             : static bool
     365      238882 : _equalRelabelType(const RelabelType *a, const RelabelType *b)
     366             : {
     367      238882 :     COMPARE_NODE_FIELD(arg);
     368      235786 :     COMPARE_SCALAR_FIELD(resulttype);
     369      235786 :     COMPARE_SCALAR_FIELD(resulttypmod);
     370      235786 :     COMPARE_SCALAR_FIELD(resultcollid);
     371             :     COMPARE_LOCATION_FIELD(location);
     372             : 
     373      235786 :     return true;
     374             : }
     375             : 
     376             : static bool
     377       43868 : _equalCoerceViaIO(const CoerceViaIO *a, const CoerceViaIO *b)
     378             : {
     379       43868 :     COMPARE_NODE_FIELD(arg);
     380       43794 :     COMPARE_SCALAR_FIELD(resulttype);
     381       43794 :     COMPARE_SCALAR_FIELD(resultcollid);
     382             :     COMPARE_LOCATION_FIELD(location);
     383             : 
     384       43794 :     return true;
     385             : }
     386             : 
     387             : static bool
     388        8380 : _equalArrayCoerceExpr(const ArrayCoerceExpr *a, const ArrayCoerceExpr *b)
     389             : {
     390        8380 :     COMPARE_NODE_FIELD(arg);
     391        8380 :     COMPARE_NODE_FIELD(elemexpr);
     392        8380 :     COMPARE_SCALAR_FIELD(resulttype);
     393        8380 :     COMPARE_SCALAR_FIELD(resulttypmod);
     394        8380 :     COMPARE_SCALAR_FIELD(resultcollid);
     395             :     COMPARE_LOCATION_FIELD(location);
     396             : 
     397        8380 :     return true;
     398             : }
     399             : 
     400             : static bool
     401         132 : _equalConvertRowtypeExpr(const ConvertRowtypeExpr *a, const ConvertRowtypeExpr *b)
     402             : {
     403         132 :     COMPARE_NODE_FIELD(arg);
     404         132 :     COMPARE_SCALAR_FIELD(resulttype);
     405             :     COMPARE_LOCATION_FIELD(location);
     406             : 
     407         132 :     return true;
     408             : }
     409             : 
     410             : static bool
     411       13406 : _equalCollateExpr(const CollateExpr *a, const CollateExpr *b)
     412             : {
     413       13406 :     COMPARE_NODE_FIELD(arg);
     414       13394 :     COMPARE_SCALAR_FIELD(collOid);
     415             :     COMPARE_LOCATION_FIELD(location);
     416             : 
     417       13394 :     return true;
     418             : }
     419             : 
     420             : static bool
     421      190490 : _equalCaseExpr(const CaseExpr *a, const CaseExpr *b)
     422             : {
     423      190490 :     COMPARE_SCALAR_FIELD(casetype);
     424      190490 :     COMPARE_SCALAR_FIELD(casecollid);
     425      190478 :     COMPARE_NODE_FIELD(arg);
     426      190448 :     COMPARE_NODE_FIELD(args);
     427      190372 :     COMPARE_NODE_FIELD(defresult);
     428             :     COMPARE_LOCATION_FIELD(location);
     429             : 
     430      190372 :     return true;
     431             : }
     432             : 
     433             : static bool
     434      333870 : _equalCaseWhen(const CaseWhen *a, const CaseWhen *b)
     435             : {
     436      333870 :     COMPARE_NODE_FIELD(expr);
     437      333794 :     COMPARE_NODE_FIELD(result);
     438             :     COMPARE_LOCATION_FIELD(location);
     439             : 
     440      333794 :     return true;
     441             : }
     442             : 
     443             : static bool
     444       37578 : _equalCaseTestExpr(const CaseTestExpr *a, const CaseTestExpr *b)
     445             : {
     446       37578 :     COMPARE_SCALAR_FIELD(typeId);
     447       37578 :     COMPARE_SCALAR_FIELD(typeMod);
     448       37578 :     COMPARE_SCALAR_FIELD(collation);
     449             : 
     450       37578 :     return true;
     451             : }
     452             : 
     453             : static bool
     454       41222 : _equalArrayExpr(const ArrayExpr *a, const ArrayExpr *b)
     455             : {
     456       41222 :     COMPARE_SCALAR_FIELD(array_typeid);
     457       41222 :     COMPARE_SCALAR_FIELD(array_collid);
     458       41222 :     COMPARE_SCALAR_FIELD(element_typeid);
     459       41222 :     COMPARE_NODE_FIELD(elements);
     460       41222 :     COMPARE_SCALAR_FIELD(multidims);
     461             :     COMPARE_LOCATION_FIELD(location);
     462             : 
     463       41222 :     return true;
     464             : }
     465             : 
     466             : static bool
     467       19460 : _equalRowExpr(const RowExpr *a, const RowExpr *b)
     468             : {
     469       19460 :     COMPARE_NODE_FIELD(args);
     470       19460 :     COMPARE_SCALAR_FIELD(row_typeid);
     471       19460 :     COMPARE_NODE_FIELD(colnames);
     472             :     COMPARE_LOCATION_FIELD(location);
     473             : 
     474       19460 :     return true;
     475             : }
     476             : 
     477             : static bool
     478         372 : _equalRowCompareExpr(const RowCompareExpr *a, const RowCompareExpr *b)
     479             : {
     480         372 :     COMPARE_SCALAR_FIELD(rctype);
     481         312 :     COMPARE_NODE_FIELD(opnos);
     482         312 :     COMPARE_NODE_FIELD(opfamilies);
     483         312 :     COMPARE_NODE_FIELD(inputcollids);
     484         312 :     COMPARE_NODE_FIELD(largs);
     485         312 :     COMPARE_NODE_FIELD(rargs);
     486             : 
     487         312 :     return true;
     488             : }
     489             : 
     490             : static bool
     491       13910 : _equalCoalesceExpr(const CoalesceExpr *a, const CoalesceExpr *b)
     492             : {
     493       13910 :     COMPARE_SCALAR_FIELD(coalescetype);
     494       13878 :     COMPARE_SCALAR_FIELD(coalescecollid);
     495       13878 :     COMPARE_NODE_FIELD(args);
     496             :     COMPARE_LOCATION_FIELD(location);
     497             : 
     498       12946 :     return true;
     499             : }
     500             : 
     501             : static bool
     502         962 : _equalMinMaxExpr(const MinMaxExpr *a, const MinMaxExpr *b)
     503             : {
     504         962 :     COMPARE_SCALAR_FIELD(minmaxtype);
     505         962 :     COMPARE_SCALAR_FIELD(minmaxcollid);
     506         962 :     COMPARE_SCALAR_FIELD(inputcollid);
     507         962 :     COMPARE_SCALAR_FIELD(op);
     508         962 :     COMPARE_NODE_FIELD(args);
     509             :     COMPARE_LOCATION_FIELD(location);
     510             : 
     511         962 :     return true;
     512             : }
     513             : 
     514             : static bool
     515       12012 : _equalSQLValueFunction(const SQLValueFunction *a, const SQLValueFunction *b)
     516             : {
     517       12012 :     COMPARE_SCALAR_FIELD(op);
     518       12012 :     COMPARE_SCALAR_FIELD(type);
     519       12012 :     COMPARE_SCALAR_FIELD(typmod);
     520             :     COMPARE_LOCATION_FIELD(location);
     521             : 
     522       12012 :     return true;
     523             : }
     524             : 
     525             : static bool
     526        2684 : _equalXmlExpr(const XmlExpr *a, const XmlExpr *b)
     527             : {
     528        2684 :     COMPARE_SCALAR_FIELD(op);
     529        2684 :     COMPARE_STRING_FIELD(name);
     530        2684 :     COMPARE_NODE_FIELD(named_args);
     531        2684 :     COMPARE_NODE_FIELD(arg_names);
     532        2684 :     COMPARE_NODE_FIELD(args);
     533        2684 :     COMPARE_SCALAR_FIELD(xmloption);
     534        2684 :     COMPARE_SCALAR_FIELD(indent);
     535        2684 :     COMPARE_SCALAR_FIELD(type);
     536        2684 :     COMPARE_SCALAR_FIELD(typmod);
     537             :     COMPARE_LOCATION_FIELD(location);
     538             : 
     539        2684 :     return true;
     540             : }
     541             : 
     542             : static bool
     543        7544 : _equalJsonFormat(const JsonFormat *a, const JsonFormat *b)
     544             : {
     545        7544 :     COMPARE_SCALAR_FIELD(format_type);
     546        7544 :     COMPARE_SCALAR_FIELD(encoding);
     547             :     COMPARE_LOCATION_FIELD(location);
     548             : 
     549        7544 :     return true;
     550             : }
     551             : 
     552             : static bool
     553        3364 : _equalJsonReturning(const JsonReturning *a, const JsonReturning *b)
     554             : {
     555        3364 :     COMPARE_NODE_FIELD(format);
     556        3364 :     COMPARE_SCALAR_FIELD(typid);
     557        3364 :     COMPARE_SCALAR_FIELD(typmod);
     558             : 
     559        3364 :     return true;
     560             : }
     561             : 
     562             : static bool
     563        3324 : _equalJsonValueExpr(const JsonValueExpr *a, const JsonValueExpr *b)
     564             : {
     565        3324 :     COMPARE_NODE_FIELD(raw_expr);
     566        3324 :     COMPARE_NODE_FIELD(formatted_expr);
     567        3324 :     COMPARE_NODE_FIELD(format);
     568             : 
     569        3324 :     return true;
     570             : }
     571             : 
     572             : static bool
     573        2324 : _equalJsonConstructorExpr(const JsonConstructorExpr *a, const JsonConstructorExpr *b)
     574             : {
     575        2324 :     COMPARE_SCALAR_FIELD(type);
     576        2324 :     COMPARE_NODE_FIELD(args);
     577        2324 :     COMPARE_NODE_FIELD(func);
     578        2324 :     COMPARE_NODE_FIELD(coercion);
     579        2324 :     COMPARE_NODE_FIELD(returning);
     580        2324 :     COMPARE_SCALAR_FIELD(absent_on_null);
     581        2324 :     COMPARE_SCALAR_FIELD(unique);
     582             :     COMPARE_LOCATION_FIELD(location);
     583             : 
     584        2324 :     return true;
     585             : }
     586             : 
     587             : static bool
     588        1364 : _equalJsonIsPredicate(const JsonIsPredicate *a, const JsonIsPredicate *b)
     589             : {
     590        1364 :     COMPARE_NODE_FIELD(expr);
     591        1364 :     COMPARE_NODE_FIELD(format);
     592        1364 :     COMPARE_SCALAR_FIELD(item_type);
     593        1364 :     COMPARE_SCALAR_FIELD(unique_keys);
     594             :     COMPARE_LOCATION_FIELD(location);
     595             : 
     596        1364 :     return true;
     597             : }
     598             : 
     599             : static bool
     600       54322 : _equalNullTest(const NullTest *a, const NullTest *b)
     601             : {
     602       54322 :     COMPARE_NODE_FIELD(arg);
     603       53068 :     COMPARE_SCALAR_FIELD(nulltesttype);
     604       52920 :     COMPARE_SCALAR_FIELD(argisrow);
     605             :     COMPARE_LOCATION_FIELD(location);
     606             : 
     607       52920 :     return true;
     608             : }
     609             : 
     610             : static bool
     611        3188 : _equalBooleanTest(const BooleanTest *a, const BooleanTest *b)
     612             : {
     613        3188 :     COMPARE_NODE_FIELD(arg);
     614        3188 :     COMPARE_SCALAR_FIELD(booltesttype);
     615             :     COMPARE_LOCATION_FIELD(location);
     616             : 
     617        3164 :     return true;
     618             : }
     619             : 
     620             : static bool
     621        3136 : _equalMergeAction(const MergeAction *a, const MergeAction *b)
     622             : {
     623        3136 :     COMPARE_SCALAR_FIELD(matched);
     624        3136 :     COMPARE_SCALAR_FIELD(commandType);
     625        3136 :     COMPARE_SCALAR_FIELD(override);
     626        3136 :     COMPARE_NODE_FIELD(qual);
     627        3136 :     COMPARE_NODE_FIELD(targetList);
     628        3136 :     COMPARE_NODE_FIELD(updateColnos);
     629             : 
     630        3136 :     return true;
     631             : }
     632             : 
     633             : static bool
     634       55062 : _equalCoerceToDomain(const CoerceToDomain *a, const CoerceToDomain *b)
     635             : {
     636       55062 :     COMPARE_NODE_FIELD(arg);
     637       54558 :     COMPARE_SCALAR_FIELD(resulttype);
     638       54558 :     COMPARE_SCALAR_FIELD(resulttypmod);
     639       54558 :     COMPARE_SCALAR_FIELD(resultcollid);
     640             :     COMPARE_LOCATION_FIELD(location);
     641             : 
     642       54558 :     return true;
     643             : }
     644             : 
     645             : static bool
     646           0 : _equalCoerceToDomainValue(const CoerceToDomainValue *a, const CoerceToDomainValue *b)
     647             : {
     648           0 :     COMPARE_SCALAR_FIELD(typeId);
     649           0 :     COMPARE_SCALAR_FIELD(typeMod);
     650           0 :     COMPARE_SCALAR_FIELD(collation);
     651             :     COMPARE_LOCATION_FIELD(location);
     652             : 
     653           0 :     return true;
     654             : }
     655             : 
     656             : static bool
     657        2640 : _equalSetToDefault(const SetToDefault *a, const SetToDefault *b)
     658             : {
     659        2640 :     COMPARE_SCALAR_FIELD(typeId);
     660        2640 :     COMPARE_SCALAR_FIELD(typeMod);
     661        2640 :     COMPARE_SCALAR_FIELD(collation);
     662             :     COMPARE_LOCATION_FIELD(location);
     663             : 
     664        2640 :     return true;
     665             : }
     666             : 
     667             : static bool
     668         944 : _equalCurrentOfExpr(const CurrentOfExpr *a, const CurrentOfExpr *b)
     669             : {
     670         944 :     COMPARE_SCALAR_FIELD(cvarno);
     671         944 :     COMPARE_STRING_FIELD(cursor_name);
     672         944 :     COMPARE_SCALAR_FIELD(cursor_param);
     673             : 
     674         944 :     return true;
     675             : }
     676             : 
     677             : static bool
     678         640 : _equalNextValueExpr(const NextValueExpr *a, const NextValueExpr *b)
     679             : {
     680         640 :     COMPARE_SCALAR_FIELD(seqid);
     681         640 :     COMPARE_SCALAR_FIELD(typeId);
     682             : 
     683         640 :     return true;
     684             : }
     685             : 
     686             : static bool
     687        3036 : _equalInferenceElem(const InferenceElem *a, const InferenceElem *b)
     688             : {
     689        3036 :     COMPARE_NODE_FIELD(expr);
     690        3036 :     COMPARE_SCALAR_FIELD(infercollid);
     691        3036 :     COMPARE_SCALAR_FIELD(inferopclass);
     692             : 
     693        3036 :     return true;
     694             : }
     695             : 
     696             : static bool
     697     2440112 : _equalTargetEntry(const TargetEntry *a, const TargetEntry *b)
     698             : {
     699     2440112 :     COMPARE_NODE_FIELD(expr);
     700     2436766 :     COMPARE_SCALAR_FIELD(resno);
     701     2436766 :     COMPARE_STRING_FIELD(resname);
     702     2436766 :     COMPARE_SCALAR_FIELD(ressortgroupref);
     703     2436722 :     COMPARE_SCALAR_FIELD(resorigtbl);
     704     2436722 :     COMPARE_SCALAR_FIELD(resorigcol);
     705     2436722 :     COMPARE_SCALAR_FIELD(resjunk);
     706             : 
     707     2436722 :     return true;
     708             : }
     709             : 
     710             : static bool
     711      803554 : _equalRangeTblRef(const RangeTblRef *a, const RangeTblRef *b)
     712             : {
     713      803554 :     COMPARE_SCALAR_FIELD(rtindex);
     714             : 
     715      803554 :     return true;
     716             : }
     717             : 
     718             : static bool
     719      280978 : _equalJoinExpr(const JoinExpr *a, const JoinExpr *b)
     720             : {
     721      280978 :     COMPARE_SCALAR_FIELD(jointype);
     722      280978 :     COMPARE_SCALAR_FIELD(isNatural);
     723      280978 :     COMPARE_NODE_FIELD(larg);
     724      280978 :     COMPARE_NODE_FIELD(rarg);
     725      280978 :     COMPARE_NODE_FIELD(usingClause);
     726      280978 :     COMPARE_NODE_FIELD(join_using_alias);
     727      280978 :     COMPARE_NODE_FIELD(quals);
     728      280978 :     COMPARE_NODE_FIELD(alias);
     729      280978 :     COMPARE_SCALAR_FIELD(rtindex);
     730             : 
     731      280978 :     return true;
     732             : }
     733             : 
     734             : static bool
     735      950566 : _equalFromExpr(const FromExpr *a, const FromExpr *b)
     736             : {
     737      950566 :     COMPARE_NODE_FIELD(fromlist);
     738      950566 :     COMPARE_NODE_FIELD(quals);
     739             : 
     740      950494 :     return true;
     741             : }
     742             : 
     743             : static bool
     744        2836 : _equalOnConflictExpr(const OnConflictExpr *a, const OnConflictExpr *b)
     745             : {
     746        2836 :     COMPARE_SCALAR_FIELD(action);
     747        2836 :     COMPARE_NODE_FIELD(arbiterElems);
     748        2836 :     COMPARE_NODE_FIELD(arbiterWhere);
     749        2836 :     COMPARE_SCALAR_FIELD(constraint);
     750        2836 :     COMPARE_NODE_FIELD(onConflictSet);
     751        2836 :     COMPARE_NODE_FIELD(onConflictWhere);
     752        2836 :     COMPARE_SCALAR_FIELD(exclRelIndex);
     753        2836 :     COMPARE_NODE_FIELD(exclRelTlist);
     754             : 
     755        2836 :     return true;
     756             : }
     757             : 
     758             : static bool
     759     1553838 : _equalQuery(const Query *a, const Query *b)
     760             : {
     761     1553838 :     COMPARE_SCALAR_FIELD(commandType);
     762     1553838 :     COMPARE_SCALAR_FIELD(querySource);
     763     1553838 :     COMPARE_SCALAR_FIELD(canSetTag);
     764     1553838 :     COMPARE_NODE_FIELD(utilityStmt);
     765     1553838 :     COMPARE_SCALAR_FIELD(resultRelation);
     766     1553838 :     COMPARE_SCALAR_FIELD(hasAggs);
     767     1553838 :     COMPARE_SCALAR_FIELD(hasWindowFuncs);
     768     1553838 :     COMPARE_SCALAR_FIELD(hasTargetSRFs);
     769     1553838 :     COMPARE_SCALAR_FIELD(hasSubLinks);
     770     1553832 :     COMPARE_SCALAR_FIELD(hasDistinctOn);
     771     1553832 :     COMPARE_SCALAR_FIELD(hasRecursive);
     772     1553832 :     COMPARE_SCALAR_FIELD(hasModifyingCTE);
     773     1553832 :     COMPARE_SCALAR_FIELD(hasForUpdate);
     774     1553832 :     COMPARE_SCALAR_FIELD(hasRowSecurity);
     775     1553832 :     COMPARE_SCALAR_FIELD(isReturn);
     776     1553832 :     COMPARE_NODE_FIELD(cteList);
     777     1553826 :     COMPARE_NODE_FIELD(rtable);
     778     1553780 :     COMPARE_NODE_FIELD(rteperminfos);
     779     1553728 :     COMPARE_NODE_FIELD(jointree);
     780     1553656 :     COMPARE_NODE_FIELD(mergeActionList);
     781     1553656 :     COMPARE_SCALAR_FIELD(mergeUseOuterJoin);
     782     1553656 :     COMPARE_NODE_FIELD(targetList);
     783     1553610 :     COMPARE_SCALAR_FIELD(override);
     784     1553610 :     COMPARE_NODE_FIELD(onConflict);
     785     1553610 :     COMPARE_NODE_FIELD(returningList);
     786     1553610 :     COMPARE_NODE_FIELD(groupClause);
     787     1553610 :     COMPARE_SCALAR_FIELD(groupDistinct);
     788     1553610 :     COMPARE_NODE_FIELD(groupingSets);
     789     1553610 :     COMPARE_NODE_FIELD(havingQual);
     790     1553610 :     COMPARE_NODE_FIELD(windowClause);
     791     1553580 :     COMPARE_NODE_FIELD(distinctClause);
     792     1553580 :     COMPARE_NODE_FIELD(sortClause);
     793     1553580 :     COMPARE_NODE_FIELD(limitOffset);
     794     1553580 :     COMPARE_NODE_FIELD(limitCount);
     795     1553580 :     COMPARE_SCALAR_FIELD(limitOption);
     796     1553580 :     COMPARE_NODE_FIELD(rowMarks);
     797     1553580 :     COMPARE_NODE_FIELD(setOperations);
     798     1553580 :     COMPARE_NODE_FIELD(constraintDeps);
     799     1553580 :     COMPARE_NODE_FIELD(withCheckOptions);
     800             :     COMPARE_LOCATION_FIELD(stmt_location);
     801     1553580 :     COMPARE_SCALAR_FIELD(stmt_len);
     802             : 
     803     1553574 :     return true;
     804             : }
     805             : 
     806             : static bool
     807     1206302 : _equalTypeName(const TypeName *a, const TypeName *b)
     808             : {
     809     1206302 :     COMPARE_NODE_FIELD(names);
     810     1206302 :     COMPARE_SCALAR_FIELD(typeOid);
     811     1206302 :     COMPARE_SCALAR_FIELD(setof);
     812     1206302 :     COMPARE_SCALAR_FIELD(pct_type);
     813     1206302 :     COMPARE_NODE_FIELD(typmods);
     814     1206302 :     COMPARE_SCALAR_FIELD(typemod);
     815     1206302 :     COMPARE_NODE_FIELD(arrayBounds);
     816             :     COMPARE_LOCATION_FIELD(location);
     817             : 
     818     1206302 :     return true;
     819             : }
     820             : 
     821             : static bool
     822     3015842 : _equalColumnRef(const ColumnRef *a, const ColumnRef *b)
     823             : {
     824     3015842 :     COMPARE_NODE_FIELD(fields);
     825             :     COMPARE_LOCATION_FIELD(location);
     826             : 
     827     3015800 :     return true;
     828             : }
     829             : 
     830             : static bool
     831      283960 : _equalParamRef(const ParamRef *a, const ParamRef *b)
     832             : {
     833      283960 :     COMPARE_SCALAR_FIELD(number);
     834             :     COMPARE_LOCATION_FIELD(location);
     835             : 
     836      283960 :     return true;
     837             : }
     838             : 
     839             : static bool
     840     1075044 : _equalA_Expr(const A_Expr *a, const A_Expr *b)
     841             : {
     842     1075044 :     COMPARE_SCALAR_FIELD(kind);
     843     1075044 :     COMPARE_NODE_FIELD(name);
     844     1075044 :     COMPARE_NODE_FIELD(lexpr);
     845     1075032 :     COMPARE_NODE_FIELD(rexpr);
     846             :     COMPARE_LOCATION_FIELD(location);
     847             : 
     848     1075032 :     return true;
     849             : }
     850             : 
     851             : static bool
     852      495918 : _equalTypeCast(const TypeCast *a, const TypeCast *b)
     853             : {
     854      495918 :     COMPARE_NODE_FIELD(arg);
     855      495918 :     COMPARE_NODE_FIELD(typeName);
     856             :     COMPARE_LOCATION_FIELD(location);
     857             : 
     858      495918 :     return true;
     859             : }
     860             : 
     861             : static bool
     862       15508 : _equalCollateClause(const CollateClause *a, const CollateClause *b)
     863             : {
     864       15508 :     COMPARE_NODE_FIELD(arg);
     865       15508 :     COMPARE_NODE_FIELD(collname);
     866             :     COMPARE_LOCATION_FIELD(location);
     867             : 
     868       15508 :     return true;
     869             : }
     870             : 
     871             : static bool
     872       84856 : _equalRoleSpec(const RoleSpec *a, const RoleSpec *b)
     873             : {
     874       84856 :     COMPARE_SCALAR_FIELD(roletype);
     875       84856 :     COMPARE_STRING_FIELD(rolename);
     876             :     COMPARE_LOCATION_FIELD(location);
     877             : 
     878       84856 :     return true;
     879             : }
     880             : 
     881             : static bool
     882      672008 : _equalFuncCall(const FuncCall *a, const FuncCall *b)
     883             : {
     884      672008 :     COMPARE_NODE_FIELD(funcname);
     885      672004 :     COMPARE_NODE_FIELD(args);
     886      672004 :     COMPARE_NODE_FIELD(agg_order);
     887      672004 :     COMPARE_NODE_FIELD(agg_filter);
     888      672004 :     COMPARE_NODE_FIELD(over);
     889      672004 :     COMPARE_SCALAR_FIELD(agg_within_group);
     890      672004 :     COMPARE_SCALAR_FIELD(agg_star);
     891      672004 :     COMPARE_SCALAR_FIELD(agg_distinct);
     892      672004 :     COMPARE_SCALAR_FIELD(func_variadic);
     893             :     COMPARE_LOCATION_FIELD(location);
     894             : 
     895      672004 :     return true;
     896             : }
     897             : 
     898             : static bool
     899      104096 : _equalA_Star(const A_Star *a, const A_Star *b)
     900             : {
     901             : 
     902      104096 :     return true;
     903             : }
     904             : 
     905             : static bool
     906       23436 : _equalA_Indices(const A_Indices *a, const A_Indices *b)
     907             : {
     908       23436 :     COMPARE_SCALAR_FIELD(is_slice);
     909       23436 :     COMPARE_NODE_FIELD(lidx);
     910       23436 :     COMPARE_NODE_FIELD(uidx);
     911             : 
     912       23436 :     return true;
     913             : }
     914             : 
     915             : static bool
     916       49132 : _equalA_Indirection(const A_Indirection *a, const A_Indirection *b)
     917             : {
     918       49132 :     COMPARE_NODE_FIELD(arg);
     919       49132 :     COMPARE_NODE_FIELD(indirection);
     920             : 
     921       49132 :     return true;
     922             : }
     923             : 
     924             : static bool
     925       13432 : _equalA_ArrayExpr(const A_ArrayExpr *a, const A_ArrayExpr *b)
     926             : {
     927       13432 :     COMPARE_NODE_FIELD(elements);
     928             :     COMPARE_LOCATION_FIELD(location);
     929             : 
     930       13432 :     return true;
     931             : }
     932             : 
     933             : static bool
     934     1980396 : _equalResTarget(const ResTarget *a, const ResTarget *b)
     935             : {
     936     1980396 :     COMPARE_STRING_FIELD(name);
     937     1980396 :     COMPARE_NODE_FIELD(indirection);
     938     1980396 :     COMPARE_NODE_FIELD(val);
     939             :     COMPARE_LOCATION_FIELD(location);
     940             : 
     941     1980392 :     return true;
     942             : }
     943             : 
     944             : static bool
     945         780 : _equalMultiAssignRef(const MultiAssignRef *a, const MultiAssignRef *b)
     946             : {
     947         780 :     COMPARE_NODE_FIELD(source);
     948         780 :     COMPARE_SCALAR_FIELD(colno);
     949         780 :     COMPARE_SCALAR_FIELD(ncolumns);
     950             : 
     951         780 :     return true;
     952             : }
     953             : 
     954             : static bool
     955      158262 : _equalSortBy(const SortBy *a, const SortBy *b)
     956             : {
     957      158262 :     COMPARE_NODE_FIELD(node);
     958      158238 :     COMPARE_SCALAR_FIELD(sortby_dir);
     959      158214 :     COMPARE_SCALAR_FIELD(sortby_nulls);
     960      158214 :     COMPARE_NODE_FIELD(useOp);
     961             :     COMPARE_LOCATION_FIELD(location);
     962             : 
     963      158214 :     return true;
     964             : }
     965             : 
     966             : static bool
     967        7932 : _equalWindowDef(const WindowDef *a, const WindowDef *b)
     968             : {
     969        7932 :     COMPARE_STRING_FIELD(name);
     970        7932 :     COMPARE_STRING_FIELD(refname);
     971        7932 :     COMPARE_NODE_FIELD(partitionClause);
     972        7932 :     COMPARE_NODE_FIELD(orderClause);
     973        7932 :     COMPARE_SCALAR_FIELD(frameOptions);
     974        7932 :     COMPARE_NODE_FIELD(startOffset);
     975        7932 :     COMPARE_NODE_FIELD(endOffset);
     976             :     COMPARE_LOCATION_FIELD(location);
     977             : 
     978        7932 :     return true;
     979             : }
     980             : 
     981             : static bool
     982       28008 : _equalRangeSubselect(const RangeSubselect *a, const RangeSubselect *b)
     983             : {
     984       28008 :     COMPARE_SCALAR_FIELD(lateral);
     985       28008 :     COMPARE_NODE_FIELD(subquery);
     986       28008 :     COMPARE_NODE_FIELD(alias);
     987             : 
     988       28008 :     return true;
     989             : }
     990             : 
     991             : static bool
     992       79916 : _equalRangeFunction(const RangeFunction *a, const RangeFunction *b)
     993             : {
     994       79916 :     COMPARE_SCALAR_FIELD(lateral);
     995       79916 :     COMPARE_SCALAR_FIELD(ordinality);
     996       79916 :     COMPARE_SCALAR_FIELD(is_rowsfrom);
     997       79916 :     COMPARE_NODE_FIELD(functions);
     998       79916 :     COMPARE_NODE_FIELD(alias);
     999       79916 :     COMPARE_NODE_FIELD(coldeflist);
    1000             : 
    1001       79916 :     return true;
    1002             : }
    1003             : 
    1004             : static bool
    1005         472 : _equalRangeTableFunc(const RangeTableFunc *a, const RangeTableFunc *b)
    1006             : {
    1007         472 :     COMPARE_SCALAR_FIELD(lateral);
    1008         472 :     COMPARE_NODE_FIELD(docexpr);
    1009         472 :     COMPARE_NODE_FIELD(rowexpr);
    1010         472 :     COMPARE_NODE_FIELD(namespaces);
    1011         472 :     COMPARE_NODE_FIELD(columns);
    1012         472 :     COMPARE_NODE_FIELD(alias);
    1013             :     COMPARE_LOCATION_FIELD(location);
    1014             : 
    1015         472 :     return true;
    1016             : }
    1017             : 
    1018             : static bool
    1019        1716 : _equalRangeTableFuncCol(const RangeTableFuncCol *a, const RangeTableFuncCol *b)
    1020             : {
    1021        1716 :     COMPARE_STRING_FIELD(colname);
    1022        1716 :     COMPARE_NODE_FIELD(typeName);
    1023        1716 :     COMPARE_SCALAR_FIELD(for_ordinality);
    1024        1716 :     COMPARE_SCALAR_FIELD(is_not_null);
    1025        1716 :     COMPARE_NODE_FIELD(colexpr);
    1026        1716 :     COMPARE_NODE_FIELD(coldefexpr);
    1027             :     COMPARE_LOCATION_FIELD(location);
    1028             : 
    1029        1716 :     return true;
    1030             : }
    1031             : 
    1032             : static bool
    1033         524 : _equalRangeTableSample(const RangeTableSample *a, const RangeTableSample *b)
    1034             : {
    1035         524 :     COMPARE_NODE_FIELD(relation);
    1036         524 :     COMPARE_NODE_FIELD(method);
    1037         524 :     COMPARE_NODE_FIELD(args);
    1038         524 :     COMPARE_NODE_FIELD(repeatable);
    1039             :     COMPARE_LOCATION_FIELD(location);
    1040             : 
    1041         524 :     return true;
    1042             : }
    1043             : 
    1044             : static bool
    1045      249936 : _equalColumnDef(const ColumnDef *a, const ColumnDef *b)
    1046             : {
    1047      249936 :     COMPARE_STRING_FIELD(colname);
    1048      249936 :     COMPARE_NODE_FIELD(typeName);
    1049      249936 :     COMPARE_STRING_FIELD(compression);
    1050      249936 :     COMPARE_SCALAR_FIELD(inhcount);
    1051      249936 :     COMPARE_SCALAR_FIELD(is_local);
    1052      249936 :     COMPARE_SCALAR_FIELD(is_not_null);
    1053      249936 :     COMPARE_SCALAR_FIELD(is_from_type);
    1054      249936 :     COMPARE_SCALAR_FIELD(storage);
    1055      249936 :     COMPARE_STRING_FIELD(storage_name);
    1056      249936 :     COMPARE_NODE_FIELD(raw_default);
    1057      249936 :     COMPARE_NODE_FIELD(cooked_default);
    1058      249936 :     COMPARE_SCALAR_FIELD(identity);
    1059      249936 :     COMPARE_NODE_FIELD(identitySequence);
    1060      249936 :     COMPARE_SCALAR_FIELD(generated);
    1061      249936 :     COMPARE_NODE_FIELD(collClause);
    1062      249936 :     COMPARE_SCALAR_FIELD(collOid);
    1063      249936 :     COMPARE_NODE_FIELD(constraints);
    1064      249936 :     COMPARE_NODE_FIELD(fdwoptions);
    1065             :     COMPARE_LOCATION_FIELD(location);
    1066             : 
    1067      249936 :     return true;
    1068             : }
    1069             : 
    1070             : static bool
    1071        2768 : _equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b)
    1072             : {
    1073        2768 :     COMPARE_NODE_FIELD(relation);
    1074        2768 :     COMPARE_SCALAR_FIELD(options);
    1075        2768 :     COMPARE_SCALAR_FIELD(relationOid);
    1076             : 
    1077        2768 :     return true;
    1078             : }
    1079             : 
    1080             : static bool
    1081       34728 : _equalIndexElem(const IndexElem *a, const IndexElem *b)
    1082             : {
    1083       34728 :     COMPARE_STRING_FIELD(name);
    1084       34620 :     COMPARE_NODE_FIELD(expr);
    1085       34620 :     COMPARE_STRING_FIELD(indexcolname);
    1086       34620 :     COMPARE_NODE_FIELD(collation);
    1087       34620 :     COMPARE_NODE_FIELD(opclass);
    1088       34620 :     COMPARE_NODE_FIELD(opclassopts);
    1089       34620 :     COMPARE_SCALAR_FIELD(ordering);
    1090       34620 :     COMPARE_SCALAR_FIELD(nulls_ordering);
    1091             : 
    1092       34620 :     return true;
    1093             : }
    1094             : 
    1095             : static bool
    1096      527668 : _equalDefElem(const DefElem *a, const DefElem *b)
    1097             : {
    1098      527668 :     COMPARE_STRING_FIELD(defnamespace);
    1099      527668 :     COMPARE_STRING_FIELD(defname);
    1100      527668 :     COMPARE_NODE_FIELD(arg);
    1101      527668 :     COMPARE_SCALAR_FIELD(defaction);
    1102             :     COMPARE_LOCATION_FIELD(location);
    1103             : 
    1104      527668 :     return true;
    1105             : }
    1106             : 
    1107             : static bool
    1108        4180 : _equalLockingClause(const LockingClause *a, const LockingClause *b)
    1109             : {
    1110        4180 :     COMPARE_NODE_FIELD(lockedRels);
    1111        4180 :     COMPARE_SCALAR_FIELD(strength);
    1112        4180 :     COMPARE_SCALAR_FIELD(waitPolicy);
    1113             : 
    1114        4180 :     return true;
    1115             : }
    1116             : 
    1117             : static bool
    1118         412 : _equalXmlSerialize(const XmlSerialize *a, const XmlSerialize *b)
    1119             : {
    1120         412 :     COMPARE_SCALAR_FIELD(xmloption);
    1121         412 :     COMPARE_NODE_FIELD(expr);
    1122         412 :     COMPARE_NODE_FIELD(typeName);
    1123         412 :     COMPARE_SCALAR_FIELD(indent);
    1124             :     COMPARE_LOCATION_FIELD(location);
    1125             : 
    1126         412 :     return true;
    1127             : }
    1128             : 
    1129             : static bool
    1130       19760 : _equalPartitionElem(const PartitionElem *a, const PartitionElem *b)
    1131             : {
    1132       19760 :     COMPARE_STRING_FIELD(name);
    1133       19760 :     COMPARE_NODE_FIELD(expr);
    1134       19760 :     COMPARE_NODE_FIELD(collation);
    1135       19760 :     COMPARE_NODE_FIELD(opclass);
    1136             :     COMPARE_LOCATION_FIELD(location);
    1137             : 
    1138       19760 :     return true;
    1139             : }
    1140             : 
    1141             : static bool
    1142       18032 : _equalPartitionSpec(const PartitionSpec *a, const PartitionSpec *b)
    1143             : {
    1144       18032 :     COMPARE_SCALAR_FIELD(strategy);
    1145       18032 :     COMPARE_NODE_FIELD(partParams);
    1146             :     COMPARE_LOCATION_FIELD(location);
    1147             : 
    1148       18032 :     return true;
    1149             : }
    1150             : 
    1151             : static bool
    1152       37920 : _equalPartitionBoundSpec(const PartitionBoundSpec *a, const PartitionBoundSpec *b)
    1153             : {
    1154       37920 :     COMPARE_SCALAR_FIELD(strategy);
    1155       37920 :     COMPARE_SCALAR_FIELD(is_default);
    1156       37920 :     COMPARE_SCALAR_FIELD(modulus);
    1157       37920 :     COMPARE_SCALAR_FIELD(remainder);
    1158       37920 :     COMPARE_NODE_FIELD(listdatums);
    1159       37920 :     COMPARE_NODE_FIELD(lowerdatums);
    1160       37920 :     COMPARE_NODE_FIELD(upperdatums);
    1161             :     COMPARE_LOCATION_FIELD(location);
    1162             : 
    1163       37920 :     return true;
    1164             : }
    1165             : 
    1166             : static bool
    1167           0 : _equalPartitionRangeDatum(const PartitionRangeDatum *a, const PartitionRangeDatum *b)
    1168             : {
    1169           0 :     COMPARE_SCALAR_FIELD(kind);
    1170           0 :     COMPARE_NODE_FIELD(value);
    1171             :     COMPARE_LOCATION_FIELD(location);
    1172             : 
    1173           0 :     return true;
    1174             : }
    1175             : 
    1176             : static bool
    1177       12180 : _equalPartitionCmd(const PartitionCmd *a, const PartitionCmd *b)
    1178             : {
    1179       12180 :     COMPARE_NODE_FIELD(name);
    1180       12180 :     COMPARE_NODE_FIELD(bound);
    1181       12180 :     COMPARE_SCALAR_FIELD(concurrent);
    1182             : 
    1183       12180 :     return true;
    1184             : }
    1185             : 
    1186             : static bool
    1187     1066240 : _equalRangeTblEntry(const RangeTblEntry *a, const RangeTblEntry *b)
    1188             : {
    1189     1066240 :     COMPARE_SCALAR_FIELD(rtekind);
    1190     1066240 :     COMPARE_SCALAR_FIELD(relid);
    1191     1066240 :     COMPARE_SCALAR_FIELD(relkind);
    1192     1066240 :     COMPARE_SCALAR_FIELD(rellockmode);
    1193     1066240 :     COMPARE_NODE_FIELD(tablesample);
    1194     1066240 :     COMPARE_SCALAR_FIELD(perminfoindex);
    1195     1066240 :     COMPARE_NODE_FIELD(subquery);
    1196     1066234 :     COMPARE_SCALAR_FIELD(security_barrier);
    1197     1066234 :     COMPARE_SCALAR_FIELD(jointype);
    1198     1066234 :     COMPARE_SCALAR_FIELD(joinmergedcols);
    1199     1066234 :     COMPARE_NODE_FIELD(joinaliasvars);
    1200     1066234 :     COMPARE_NODE_FIELD(joinleftcols);
    1201     1066234 :     COMPARE_NODE_FIELD(joinrightcols);
    1202     1066234 :     COMPARE_NODE_FIELD(join_using_alias);
    1203     1066234 :     COMPARE_NODE_FIELD(functions);
    1204     1066234 :     COMPARE_SCALAR_FIELD(funcordinality);
    1205     1066234 :     COMPARE_NODE_FIELD(tablefunc);
    1206     1066234 :     COMPARE_NODE_FIELD(values_lists);
    1207     1066234 :     COMPARE_STRING_FIELD(ctename);
    1208     1066234 :     COMPARE_SCALAR_FIELD(ctelevelsup);
    1209     1066234 :     COMPARE_SCALAR_FIELD(self_reference);
    1210     1066234 :     COMPARE_NODE_FIELD(coltypes);
    1211     1066234 :     COMPARE_NODE_FIELD(coltypmods);
    1212     1066234 :     COMPARE_NODE_FIELD(colcollations);
    1213     1066234 :     COMPARE_STRING_FIELD(enrname);
    1214     1066234 :     COMPARE_SCALAR_FIELD(enrtuples);
    1215     1066234 :     COMPARE_NODE_FIELD(alias);
    1216     1066234 :     COMPARE_NODE_FIELD(eref);
    1217     1066234 :     COMPARE_SCALAR_FIELD(lateral);
    1218     1066234 :     COMPARE_SCALAR_FIELD(inh);
    1219     1066234 :     COMPARE_SCALAR_FIELD(inFromCl);
    1220     1066234 :     COMPARE_NODE_FIELD(securityQuals);
    1221             : 
    1222     1066234 :     return true;
    1223             : }
    1224             : 
    1225             : static bool
    1226      761874 : _equalRTEPermissionInfo(const RTEPermissionInfo *a, const RTEPermissionInfo *b)
    1227             : {
    1228      761874 :     COMPARE_SCALAR_FIELD(relid);
    1229      761874 :     COMPARE_SCALAR_FIELD(inh);
    1230      761874 :     COMPARE_SCALAR_FIELD(requiredPerms);
    1231      761874 :     COMPARE_SCALAR_FIELD(checkAsUser);
    1232      761822 :     COMPARE_BITMAPSET_FIELD(selectedCols);
    1233      761822 :     COMPARE_BITMAPSET_FIELD(insertedCols);
    1234      761822 :     COMPARE_BITMAPSET_FIELD(updatedCols);
    1235             : 
    1236      761822 :     return true;
    1237             : }
    1238             : 
    1239             : static bool
    1240       77598 : _equalRangeTblFunction(const RangeTblFunction *a, const RangeTblFunction *b)
    1241             : {
    1242       77598 :     COMPARE_NODE_FIELD(funcexpr);
    1243       77598 :     COMPARE_SCALAR_FIELD(funccolcount);
    1244       77598 :     COMPARE_NODE_FIELD(funccolnames);
    1245       77598 :     COMPARE_NODE_FIELD(funccoltypes);
    1246       77598 :     COMPARE_NODE_FIELD(funccoltypmods);
    1247       77598 :     COMPARE_NODE_FIELD(funccolcollations);
    1248       77598 :     COMPARE_BITMAPSET_FIELD(funcparams);
    1249             : 
    1250       77598 :     return true;
    1251             : }
    1252             : 
    1253             : static bool
    1254         404 : _equalTableSampleClause(const TableSampleClause *a, const TableSampleClause *b)
    1255             : {
    1256         404 :     COMPARE_SCALAR_FIELD(tsmhandler);
    1257         404 :     COMPARE_NODE_FIELD(args);
    1258         404 :     COMPARE_NODE_FIELD(repeatable);
    1259             : 
    1260         404 :     return true;
    1261             : }
    1262             : 
    1263             : static bool
    1264        6866 : _equalWithCheckOption(const WithCheckOption *a, const WithCheckOption *b)
    1265             : {
    1266        6866 :     COMPARE_SCALAR_FIELD(kind);
    1267        4952 :     COMPARE_STRING_FIELD(relname);
    1268        4952 :     COMPARE_STRING_FIELD(polname);
    1269        4782 :     COMPARE_NODE_FIELD(qual);
    1270        4386 :     COMPARE_SCALAR_FIELD(cascaded);
    1271             : 
    1272        4386 :     return true;
    1273             : }
    1274             : 
    1275             : static bool
    1276      219868 : _equalSortGroupClause(const SortGroupClause *a, const SortGroupClause *b)
    1277             : {
    1278      219868 :     COMPARE_SCALAR_FIELD(tleSortGroupRef);
    1279      218308 :     COMPARE_SCALAR_FIELD(eqop);
    1280      218308 :     COMPARE_SCALAR_FIELD(sortop);
    1281      218272 :     COMPARE_SCALAR_FIELD(nulls_first);
    1282      218266 :     COMPARE_SCALAR_FIELD(hashable);
    1283             : 
    1284      218266 :     return true;
    1285             : }
    1286             : 
    1287             : static bool
    1288        7328 : _equalGroupingSet(const GroupingSet *a, const GroupingSet *b)
    1289             : {
    1290        7328 :     COMPARE_SCALAR_FIELD(kind);
    1291        7328 :     COMPARE_NODE_FIELD(content);
    1292             :     COMPARE_LOCATION_FIELD(location);
    1293             : 
    1294        7328 :     return true;
    1295             : }
    1296             : 
    1297             : static bool
    1298        5076 : _equalWindowClause(const WindowClause *a, const WindowClause *b)
    1299             : {
    1300        5076 :     COMPARE_STRING_FIELD(name);
    1301        5076 :     COMPARE_STRING_FIELD(refname);
    1302        5076 :     COMPARE_NODE_FIELD(partitionClause);
    1303        5076 :     COMPARE_NODE_FIELD(orderClause);
    1304        5076 :     COMPARE_SCALAR_FIELD(frameOptions);
    1305        5046 :     COMPARE_NODE_FIELD(startOffset);
    1306        5046 :     COMPARE_NODE_FIELD(endOffset);
    1307        5046 :     COMPARE_NODE_FIELD(runCondition);
    1308        5046 :     COMPARE_SCALAR_FIELD(startInRangeFunc);
    1309        5046 :     COMPARE_SCALAR_FIELD(endInRangeFunc);
    1310        5046 :     COMPARE_SCALAR_FIELD(inRangeColl);
    1311        5046 :     COMPARE_SCALAR_FIELD(inRangeAsc);
    1312        5046 :     COMPARE_SCALAR_FIELD(inRangeNullsFirst);
    1313        5046 :     COMPARE_SCALAR_FIELD(winref);
    1314        5046 :     COMPARE_SCALAR_FIELD(copiedOrder);
    1315             : 
    1316        5046 :     return true;
    1317             : }
    1318             : 
    1319             : static bool
    1320        9564 : _equalRowMarkClause(const RowMarkClause *a, const RowMarkClause *b)
    1321             : {
    1322        9564 :     COMPARE_SCALAR_FIELD(rti);
    1323        9564 :     COMPARE_SCALAR_FIELD(strength);
    1324        9564 :     COMPARE_SCALAR_FIELD(waitPolicy);
    1325        9564 :     COMPARE_SCALAR_FIELD(pushedDown);
    1326             : 
    1327        9564 :     return true;
    1328             : }
    1329             : 
    1330             : static bool
    1331        5260 : _equalWithClause(const WithClause *a, const WithClause *b)
    1332             : {
    1333        5260 :     COMPARE_NODE_FIELD(ctes);
    1334        5260 :     COMPARE_SCALAR_FIELD(recursive);
    1335             :     COMPARE_LOCATION_FIELD(location);
    1336             : 
    1337        5260 :     return true;
    1338             : }
    1339             : 
    1340             : static bool
    1341        2632 : _equalInferClause(const InferClause *a, const InferClause *b)
    1342             : {
    1343        2632 :     COMPARE_NODE_FIELD(indexElems);
    1344        2632 :     COMPARE_NODE_FIELD(whereClause);
    1345        2632 :     COMPARE_STRING_FIELD(conname);
    1346             :     COMPARE_LOCATION_FIELD(location);
    1347             : 
    1348        2632 :     return true;
    1349             : }
    1350             : 
    1351             : static bool
    1352        2968 : _equalOnConflictClause(const OnConflictClause *a, const OnConflictClause *b)
    1353             : {
    1354        2968 :     COMPARE_SCALAR_FIELD(action);
    1355        2968 :     COMPARE_NODE_FIELD(infer);
    1356        2968 :     COMPARE_NODE_FIELD(targetList);
    1357        2968 :     COMPARE_NODE_FIELD(whereClause);
    1358             :     COMPARE_LOCATION_FIELD(location);
    1359             : 
    1360        2968 :     return true;
    1361             : }
    1362             : 
    1363             : static bool
    1364         420 : _equalCTESearchClause(const CTESearchClause *a, const CTESearchClause *b)
    1365             : {
    1366         420 :     COMPARE_NODE_FIELD(search_col_list);
    1367         420 :     COMPARE_SCALAR_FIELD(search_breadth_first);
    1368         420 :     COMPARE_STRING_FIELD(search_seq_column);
    1369             :     COMPARE_LOCATION_FIELD(location);
    1370             : 
    1371         420 :     return true;
    1372             : }
    1373             : 
    1374             : static bool
    1375         420 : _equalCTECycleClause(const CTECycleClause *a, const CTECycleClause *b)
    1376             : {
    1377         420 :     COMPARE_NODE_FIELD(cycle_col_list);
    1378         420 :     COMPARE_STRING_FIELD(cycle_mark_column);
    1379         420 :     COMPARE_NODE_FIELD(cycle_mark_value);
    1380         420 :     COMPARE_NODE_FIELD(cycle_mark_default);
    1381         420 :     COMPARE_STRING_FIELD(cycle_path_column);
    1382             :     COMPARE_LOCATION_FIELD(location);
    1383         420 :     COMPARE_SCALAR_FIELD(cycle_mark_type);
    1384         420 :     COMPARE_SCALAR_FIELD(cycle_mark_typmod);
    1385         420 :     COMPARE_SCALAR_FIELD(cycle_mark_collation);
    1386         420 :     COMPARE_SCALAR_FIELD(cycle_mark_neop);
    1387             : 
    1388         420 :     return true;
    1389             : }
    1390             : 
    1391             : static bool
    1392       13388 : _equalCommonTableExpr(const CommonTableExpr *a, const CommonTableExpr *b)
    1393             : {
    1394       13388 :     COMPARE_STRING_FIELD(ctename);
    1395       13388 :     COMPARE_NODE_FIELD(aliascolnames);
    1396       13388 :     COMPARE_SCALAR_FIELD(ctematerialized);
    1397       13388 :     COMPARE_NODE_FIELD(ctequery);
    1398       13382 :     COMPARE_NODE_FIELD(search_clause);
    1399       13382 :     COMPARE_NODE_FIELD(cycle_clause);
    1400             :     COMPARE_LOCATION_FIELD(location);
    1401       13382 :     COMPARE_SCALAR_FIELD(cterecursive);
    1402       13382 :     COMPARE_SCALAR_FIELD(cterefcount);
    1403       13382 :     COMPARE_NODE_FIELD(ctecolnames);
    1404       13382 :     COMPARE_NODE_FIELD(ctecoltypes);
    1405       13382 :     COMPARE_NODE_FIELD(ctecoltypmods);
    1406       13382 :     COMPARE_NODE_FIELD(ctecolcollations);
    1407             : 
    1408       13382 :     return true;
    1409             : }
    1410             : 
    1411             : static bool
    1412        3352 : _equalMergeWhenClause(const MergeWhenClause *a, const MergeWhenClause *b)
    1413             : {
    1414        3352 :     COMPARE_SCALAR_FIELD(matched);
    1415        3352 :     COMPARE_SCALAR_FIELD(commandType);
    1416        3352 :     COMPARE_SCALAR_FIELD(override);
    1417        3352 :     COMPARE_NODE_FIELD(condition);
    1418        3352 :     COMPARE_NODE_FIELD(targetList);
    1419        3352 :     COMPARE_NODE_FIELD(values);
    1420             : 
    1421        3352 :     return true;
    1422             : }
    1423             : 
    1424             : static bool
    1425        2248 : _equalTriggerTransition(const TriggerTransition *a, const TriggerTransition *b)
    1426             : {
    1427        2248 :     COMPARE_STRING_FIELD(name);
    1428        2248 :     COMPARE_SCALAR_FIELD(isNew);
    1429        2248 :     COMPARE_SCALAR_FIELD(isTable);
    1430             : 
    1431        2248 :     return true;
    1432             : }
    1433             : 
    1434             : static bool
    1435        1040 : _equalJsonOutput(const JsonOutput *a, const JsonOutput *b)
    1436             : {
    1437        1040 :     COMPARE_NODE_FIELD(typeName);
    1438        1040 :     COMPARE_NODE_FIELD(returning);
    1439             : 
    1440        1040 :     return true;
    1441             : }
    1442             : 
    1443             : static bool
    1444        1388 : _equalJsonKeyValue(const JsonKeyValue *a, const JsonKeyValue *b)
    1445             : {
    1446        1388 :     COMPARE_NODE_FIELD(key);
    1447        1388 :     COMPARE_NODE_FIELD(value);
    1448             : 
    1449        1388 :     return true;
    1450             : }
    1451             : 
    1452             : static bool
    1453         328 : _equalJsonParseExpr(const JsonParseExpr *a, const JsonParseExpr *b)
    1454             : {
    1455         328 :     COMPARE_NODE_FIELD(expr);
    1456         328 :     COMPARE_NODE_FIELD(output);
    1457         328 :     COMPARE_SCALAR_FIELD(unique_keys);
    1458             :     COMPARE_LOCATION_FIELD(location);
    1459             : 
    1460         328 :     return true;
    1461             : }
    1462             : 
    1463             : static bool
    1464         224 : _equalJsonScalarExpr(const JsonScalarExpr *a, const JsonScalarExpr *b)
    1465             : {
    1466         224 :     COMPARE_NODE_FIELD(expr);
    1467         224 :     COMPARE_NODE_FIELD(output);
    1468             :     COMPARE_LOCATION_FIELD(location);
    1469             : 
    1470         224 :     return true;
    1471             : }
    1472             : 
    1473             : static bool
    1474         180 : _equalJsonSerializeExpr(const JsonSerializeExpr *a, const JsonSerializeExpr *b)
    1475             : {
    1476         180 :     COMPARE_NODE_FIELD(expr);
    1477         180 :     COMPARE_NODE_FIELD(output);
    1478             :     COMPARE_LOCATION_FIELD(location);
    1479             : 
    1480         180 :     return true;
    1481             : }
    1482             : 
    1483             : static bool
    1484         760 : _equalJsonObjectConstructor(const JsonObjectConstructor *a, const JsonObjectConstructor *b)
    1485             : {
    1486         760 :     COMPARE_NODE_FIELD(exprs);
    1487         760 :     COMPARE_NODE_FIELD(output);
    1488         760 :     COMPARE_SCALAR_FIELD(absent_on_null);
    1489         760 :     COMPARE_SCALAR_FIELD(unique);
    1490             :     COMPARE_LOCATION_FIELD(location);
    1491             : 
    1492         760 :     return true;
    1493             : }
    1494             : 
    1495             : static bool
    1496         376 : _equalJsonArrayConstructor(const JsonArrayConstructor *a, const JsonArrayConstructor *b)
    1497             : {
    1498         376 :     COMPARE_NODE_FIELD(exprs);
    1499         376 :     COMPARE_NODE_FIELD(output);
    1500         376 :     COMPARE_SCALAR_FIELD(absent_on_null);
    1501             :     COMPARE_LOCATION_FIELD(location);
    1502             : 
    1503         376 :     return true;
    1504             : }
    1505             : 
    1506             : static bool
    1507         120 : _equalJsonArrayQueryConstructor(const JsonArrayQueryConstructor *a, const JsonArrayQueryConstructor *b)
    1508             : {
    1509         120 :     COMPARE_NODE_FIELD(query);
    1510         120 :     COMPARE_NODE_FIELD(output);
    1511         120 :     COMPARE_NODE_FIELD(format);
    1512         120 :     COMPARE_SCALAR_FIELD(absent_on_null);
    1513             :     COMPARE_LOCATION_FIELD(location);
    1514             : 
    1515         120 :     return true;
    1516             : }
    1517             : 
    1518             : static bool
    1519         636 : _equalJsonAggConstructor(const JsonAggConstructor *a, const JsonAggConstructor *b)
    1520             : {
    1521         636 :     COMPARE_NODE_FIELD(output);
    1522         636 :     COMPARE_NODE_FIELD(agg_filter);
    1523         636 :     COMPARE_NODE_FIELD(agg_order);
    1524         636 :     COMPARE_NODE_FIELD(over);
    1525             :     COMPARE_LOCATION_FIELD(location);
    1526             : 
    1527         636 :     return true;
    1528             : }
    1529             : 
    1530             : static bool
    1531         324 : _equalJsonObjectAgg(const JsonObjectAgg *a, const JsonObjectAgg *b)
    1532             : {
    1533         324 :     COMPARE_NODE_FIELD(constructor);
    1534         324 :     COMPARE_NODE_FIELD(arg);
    1535         324 :     COMPARE_SCALAR_FIELD(absent_on_null);
    1536         324 :     COMPARE_SCALAR_FIELD(unique);
    1537             : 
    1538         324 :     return true;
    1539             : }
    1540             : 
    1541             : static bool
    1542         312 : _equalJsonArrayAgg(const JsonArrayAgg *a, const JsonArrayAgg *b)
    1543             : {
    1544         312 :     COMPARE_NODE_FIELD(constructor);
    1545         312 :     COMPARE_NODE_FIELD(arg);
    1546         312 :     COMPARE_SCALAR_FIELD(absent_on_null);
    1547             : 
    1548         312 :     return true;
    1549             : }
    1550             : 
    1551             : static bool
    1552     1268560 : _equalRawStmt(const RawStmt *a, const RawStmt *b)
    1553             : {
    1554     1268560 :     COMPARE_NODE_FIELD(stmt);
    1555             :     COMPARE_LOCATION_FIELD(stmt_location);
    1556     1268556 :     COMPARE_SCALAR_FIELD(stmt_len);
    1557             : 
    1558     1268556 :     return true;
    1559             : }
    1560             : 
    1561             : static bool
    1562      115540 : _equalInsertStmt(const InsertStmt *a, const InsertStmt *b)
    1563             : {
    1564      115540 :     COMPARE_NODE_FIELD(relation);
    1565      115540 :     COMPARE_NODE_FIELD(cols);
    1566      115540 :     COMPARE_NODE_FIELD(selectStmt);
    1567      115540 :     COMPARE_NODE_FIELD(onConflictClause);
    1568      115540 :     COMPARE_NODE_FIELD(returningList);
    1569      115540 :     COMPARE_NODE_FIELD(withClause);
    1570      115540 :     COMPARE_SCALAR_FIELD(override);
    1571             : 
    1572      115540 :     return true;
    1573             : }
    1574             : 
    1575             : static bool
    1576        8108 : _equalDeleteStmt(const DeleteStmt *a, const DeleteStmt *b)
    1577             : {
    1578        8108 :     COMPARE_NODE_FIELD(relation);
    1579        8108 :     COMPARE_NODE_FIELD(usingClause);
    1580        8108 :     COMPARE_NODE_FIELD(whereClause);
    1581        8108 :     COMPARE_NODE_FIELD(returningList);
    1582        8108 :     COMPARE_NODE_FIELD(withClause);
    1583             : 
    1584        8108 :     return true;
    1585             : }
    1586             : 
    1587             : static bool
    1588       24888 : _equalUpdateStmt(const UpdateStmt *a, const UpdateStmt *b)
    1589             : {
    1590       24888 :     COMPARE_NODE_FIELD(relation);
    1591       24888 :     COMPARE_NODE_FIELD(targetList);
    1592       24888 :     COMPARE_NODE_FIELD(whereClause);
    1593       24888 :     COMPARE_NODE_FIELD(fromClause);
    1594       24888 :     COMPARE_NODE_FIELD(returningList);
    1595       24888 :     COMPARE_NODE_FIELD(withClause);
    1596             : 
    1597       24888 :     return true;
    1598             : }
    1599             : 
    1600             : static bool
    1601        2084 : _equalMergeStmt(const MergeStmt *a, const MergeStmt *b)
    1602             : {
    1603        2084 :     COMPARE_NODE_FIELD(relation);
    1604        2084 :     COMPARE_NODE_FIELD(sourceRelation);
    1605        2084 :     COMPARE_NODE_FIELD(joinCondition);
    1606        2084 :     COMPARE_NODE_FIELD(mergeWhenClauses);
    1607        2084 :     COMPARE_NODE_FIELD(withClause);
    1608             : 
    1609        2084 :     return true;
    1610             : }
    1611             : 
    1612             : static bool
    1613      901584 : _equalSelectStmt(const SelectStmt *a, const SelectStmt *b)
    1614             : {
    1615      901584 :     COMPARE_NODE_FIELD(distinctClause);
    1616      901584 :     COMPARE_NODE_FIELD(intoClause);
    1617      901584 :     COMPARE_NODE_FIELD(targetList);
    1618      901580 :     COMPARE_NODE_FIELD(fromClause);
    1619      901580 :     COMPARE_NODE_FIELD(whereClause);
    1620      901580 :     COMPARE_NODE_FIELD(groupClause);
    1621      901580 :     COMPARE_SCALAR_FIELD(groupDistinct);
    1622      901580 :     COMPARE_NODE_FIELD(havingClause);
    1623      901580 :     COMPARE_NODE_FIELD(windowClause);
    1624      901580 :     COMPARE_NODE_FIELD(valuesLists);
    1625      901580 :     COMPARE_NODE_FIELD(sortClause);
    1626      901580 :     COMPARE_NODE_FIELD(limitOffset);
    1627      901580 :     COMPARE_NODE_FIELD(limitCount);
    1628      901580 :     COMPARE_SCALAR_FIELD(limitOption);
    1629      901580 :     COMPARE_NODE_FIELD(lockingClause);
    1630      901580 :     COMPARE_NODE_FIELD(withClause);
    1631      901580 :     COMPARE_SCALAR_FIELD(op);
    1632      901580 :     COMPARE_SCALAR_FIELD(all);
    1633      901580 :     COMPARE_NODE_FIELD(larg);
    1634      901580 :     COMPARE_NODE_FIELD(rarg);
    1635             : 
    1636      901580 :     return true;
    1637             : }
    1638             : 
    1639             : static bool
    1640       19940 : _equalSetOperationStmt(const SetOperationStmt *a, const SetOperationStmt *b)
    1641             : {
    1642       19940 :     COMPARE_SCALAR_FIELD(op);
    1643       19940 :     COMPARE_SCALAR_FIELD(all);
    1644       19940 :     COMPARE_NODE_FIELD(larg);
    1645       19940 :     COMPARE_NODE_FIELD(rarg);
    1646       19940 :     COMPARE_NODE_FIELD(colTypes);
    1647       19940 :     COMPARE_NODE_FIELD(colTypmods);
    1648       19940 :     COMPARE_NODE_FIELD(colCollations);
    1649       19940 :     COMPARE_NODE_FIELD(groupClauses);
    1650             : 
    1651       19940 :     return true;
    1652             : }
    1653             : 
    1654             : static bool
    1655       12088 : _equalReturnStmt(const ReturnStmt *a, const ReturnStmt *b)
    1656             : {
    1657       12088 :     COMPARE_NODE_FIELD(returnval);
    1658             : 
    1659       12088 :     return true;
    1660             : }
    1661             : 
    1662             : static bool
    1663           0 : _equalPLAssignStmt(const PLAssignStmt *a, const PLAssignStmt *b)
    1664             : {
    1665           0 :     COMPARE_STRING_FIELD(name);
    1666           0 :     COMPARE_NODE_FIELD(indirection);
    1667           0 :     COMPARE_SCALAR_FIELD(nnames);
    1668           0 :     COMPARE_NODE_FIELD(val);
    1669             :     COMPARE_LOCATION_FIELD(location);
    1670             : 
    1671           0 :     return true;
    1672             : }
    1673             : 
    1674             : static bool
    1675        3640 : _equalCreateSchemaStmt(const CreateSchemaStmt *a, const CreateSchemaStmt *b)
    1676             : {
    1677        3640 :     COMPARE_STRING_FIELD(schemaname);
    1678        3640 :     COMPARE_NODE_FIELD(authrole);
    1679        3640 :     COMPARE_NODE_FIELD(schemaElts);
    1680        3640 :     COMPARE_SCALAR_FIELD(if_not_exists);
    1681             : 
    1682        3640 :     return true;
    1683             : }
    1684             : 
    1685             : static bool
    1686       92984 : _equalAlterTableStmt(const AlterTableStmt *a, const AlterTableStmt *b)
    1687             : {
    1688       92984 :     COMPARE_NODE_FIELD(relation);
    1689       92984 :     COMPARE_NODE_FIELD(cmds);
    1690       92984 :     COMPARE_SCALAR_FIELD(objtype);
    1691       92984 :     COMPARE_SCALAR_FIELD(missing_ok);
    1692             : 
    1693       92984 :     return true;
    1694             : }
    1695             : 
    1696             : static bool
    1697        1672 : _equalReplicaIdentityStmt(const ReplicaIdentityStmt *a, const ReplicaIdentityStmt *b)
    1698             : {
    1699        1672 :     COMPARE_SCALAR_FIELD(identity_type);
    1700        1672 :     COMPARE_STRING_FIELD(name);
    1701             : 
    1702        1672 :     return true;
    1703             : }
    1704             : 
    1705             : static bool
    1706       96200 : _equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b)
    1707             : {
    1708       96200 :     COMPARE_SCALAR_FIELD(subtype);
    1709       96200 :     COMPARE_STRING_FIELD(name);
    1710       96200 :     COMPARE_SCALAR_FIELD(num);
    1711       96200 :     COMPARE_NODE_FIELD(newowner);
    1712       96200 :     COMPARE_NODE_FIELD(def);
    1713       96200 :     COMPARE_SCALAR_FIELD(behavior);
    1714       96200 :     COMPARE_SCALAR_FIELD(missing_ok);
    1715       96200 :     COMPARE_SCALAR_FIELD(recurse);
    1716             : 
    1717       96200 :     return true;
    1718             : }
    1719             : 
    1720             : static bool
    1721           8 : _equalAlterCollationStmt(const AlterCollationStmt *a, const AlterCollationStmt *b)
    1722             : {
    1723           8 :     COMPARE_NODE_FIELD(collname);
    1724             : 
    1725           8 :     return true;
    1726             : }
    1727             : 
    1728             : static bool
    1729         960 : _equalAlterDomainStmt(const AlterDomainStmt *a, const AlterDomainStmt *b)
    1730             : {
    1731         960 :     COMPARE_SCALAR_FIELD(subtype);
    1732         960 :     COMPARE_NODE_FIELD(typeName);
    1733         960 :     COMPARE_STRING_FIELD(name);
    1734         960 :     COMPARE_NODE_FIELD(def);
    1735         960 :     COMPARE_SCALAR_FIELD(behavior);
    1736         960 :     COMPARE_SCALAR_FIELD(missing_ok);
    1737             : 
    1738         960 :     return true;
    1739             : }
    1740             : 
    1741             : static bool
    1742       51204 : _equalGrantStmt(const GrantStmt *a, const GrantStmt *b)
    1743             : {
    1744       51204 :     COMPARE_SCALAR_FIELD(is_grant);
    1745       51204 :     COMPARE_SCALAR_FIELD(targtype);
    1746       51204 :     COMPARE_SCALAR_FIELD(objtype);
    1747       51204 :     COMPARE_NODE_FIELD(objects);
    1748       51204 :     COMPARE_NODE_FIELD(privileges);
    1749       51204 :     COMPARE_NODE_FIELD(grantees);
    1750       51204 :     COMPARE_SCALAR_FIELD(grant_option);
    1751       51204 :     COMPARE_NODE_FIELD(grantor);
    1752       51204 :     COMPARE_SCALAR_FIELD(behavior);
    1753             : 
    1754       51204 :     return true;
    1755             : }
    1756             : 
    1757             : static bool
    1758       61364 : _equalObjectWithArgs(const ObjectWithArgs *a, const ObjectWithArgs *b)
    1759             : {
    1760       61364 :     COMPARE_NODE_FIELD(objname);
    1761       61364 :     COMPARE_NODE_FIELD(objargs);
    1762       61364 :     COMPARE_NODE_FIELD(objfuncargs);
    1763       61364 :     COMPARE_SCALAR_FIELD(args_unspecified);
    1764             : 
    1765       61364 :     return true;
    1766             : }
    1767             : 
    1768             : static bool
    1769       48572 : _equalAccessPriv(const AccessPriv *a, const AccessPriv *b)
    1770             : {
    1771       48572 :     COMPARE_STRING_FIELD(priv_name);
    1772       48572 :     COMPARE_NODE_FIELD(cols);
    1773             : 
    1774       48572 :     return true;
    1775             : }
    1776             : 
    1777             : static bool
    1778        3240 : _equalGrantRoleStmt(const GrantRoleStmt *a, const GrantRoleStmt *b)
    1779             : {
    1780        3240 :     COMPARE_NODE_FIELD(granted_roles);
    1781        3240 :     COMPARE_NODE_FIELD(grantee_roles);
    1782        3240 :     COMPARE_SCALAR_FIELD(is_grant);
    1783        3240 :     COMPARE_NODE_FIELD(opt);
    1784        3240 :     COMPARE_NODE_FIELD(grantor);
    1785        3240 :     COMPARE_SCALAR_FIELD(behavior);
    1786             : 
    1787        3240 :     return true;
    1788             : }
    1789             : 
    1790             : static bool
    1791         640 : _equalAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *a, const AlterDefaultPrivilegesStmt *b)
    1792             : {
    1793         640 :     COMPARE_NODE_FIELD(options);
    1794         640 :     COMPARE_NODE_FIELD(action);
    1795             : 
    1796         640 :     return true;
    1797             : }
    1798             : 
    1799             : static bool
    1800       35128 : _equalCopyStmt(const CopyStmt *a, const CopyStmt *b)
    1801             : {
    1802       35128 :     COMPARE_NODE_FIELD(relation);
    1803       35128 :     COMPARE_NODE_FIELD(query);
    1804       35128 :     COMPARE_NODE_FIELD(attlist);
    1805       35128 :     COMPARE_SCALAR_FIELD(is_from);
    1806       35128 :     COMPARE_SCALAR_FIELD(is_program);
    1807       35128 :     COMPARE_STRING_FIELD(filename);
    1808       35128 :     COMPARE_NODE_FIELD(options);
    1809       35128 :     COMPARE_NODE_FIELD(whereClause);
    1810             : 
    1811       35128 :     return true;
    1812             : }
    1813             : 
    1814             : static bool
    1815       90768 : _equalVariableSetStmt(const VariableSetStmt *a, const VariableSetStmt *b)
    1816             : {
    1817       90768 :     COMPARE_SCALAR_FIELD(kind);
    1818       90768 :     COMPARE_STRING_FIELD(name);
    1819       90768 :     COMPARE_NODE_FIELD(args);
    1820       90768 :     COMPARE_SCALAR_FIELD(is_local);
    1821             : 
    1822       90768 :     return true;
    1823             : }
    1824             : 
    1825             : static bool
    1826        3264 : _equalVariableShowStmt(const VariableShowStmt *a, const VariableShowStmt *b)
    1827             : {
    1828        3264 :     COMPARE_STRING_FIELD(name);
    1829             : 
    1830        3264 :     return true;
    1831             : }
    1832             : 
    1833             : static bool
    1834      130904 : _equalCreateStmt(const CreateStmt *a, const CreateStmt *b)
    1835             : {
    1836      130904 :     COMPARE_NODE_FIELD(relation);
    1837      130904 :     COMPARE_NODE_FIELD(tableElts);
    1838      130904 :     COMPARE_NODE_FIELD(inhRelations);
    1839      130904 :     COMPARE_NODE_FIELD(partbound);
    1840      130904 :     COMPARE_NODE_FIELD(partspec);
    1841      130904 :     COMPARE_NODE_FIELD(ofTypename);
    1842      130904 :     COMPARE_NODE_FIELD(constraints);
    1843      130904 :     COMPARE_NODE_FIELD(nnconstraints);
    1844      130904 :     COMPARE_NODE_FIELD(options);
    1845      130904 :     COMPARE_SCALAR_FIELD(oncommit);
    1846      130904 :     COMPARE_STRING_FIELD(tablespacename);
    1847      130904 :     COMPARE_STRING_FIELD(accessMethod);
    1848      130904 :     COMPARE_SCALAR_FIELD(if_not_exists);
    1849             : 
    1850      130904 :     return true;
    1851             : }
    1852             : 
    1853             : static bool
    1854      107588 : _equalConstraint(const Constraint *a, const Constraint *b)
    1855             : {
    1856      107588 :     COMPARE_SCALAR_FIELD(contype);
    1857      107588 :     COMPARE_STRING_FIELD(conname);
    1858      107588 :     COMPARE_SCALAR_FIELD(deferrable);
    1859      107588 :     COMPARE_SCALAR_FIELD(initdeferred);
    1860             :     COMPARE_LOCATION_FIELD(location);
    1861      107588 :     COMPARE_SCALAR_FIELD(is_no_inherit);
    1862      107588 :     COMPARE_NODE_FIELD(raw_expr);
    1863      107588 :     COMPARE_STRING_FIELD(cooked_expr);
    1864      107588 :     COMPARE_SCALAR_FIELD(generated_when);
    1865      107588 :     COMPARE_SCALAR_FIELD(inhcount);
    1866      107588 :     COMPARE_SCALAR_FIELD(nulls_not_distinct);
    1867      107588 :     COMPARE_NODE_FIELD(keys);
    1868      107588 :     COMPARE_NODE_FIELD(including);
    1869      107588 :     COMPARE_NODE_FIELD(exclusions);
    1870      107588 :     COMPARE_NODE_FIELD(options);
    1871      107588 :     COMPARE_STRING_FIELD(indexname);
    1872      107588 :     COMPARE_STRING_FIELD(indexspace);
    1873      107588 :     COMPARE_SCALAR_FIELD(reset_default_tblspc);
    1874      107588 :     COMPARE_STRING_FIELD(access_method);
    1875      107588 :     COMPARE_NODE_FIELD(where_clause);
    1876      107588 :     COMPARE_NODE_FIELD(pktable);
    1877      107588 :     COMPARE_NODE_FIELD(fk_attrs);
    1878      107588 :     COMPARE_NODE_FIELD(pk_attrs);
    1879      107588 :     COMPARE_SCALAR_FIELD(fk_matchtype);
    1880      107588 :     COMPARE_SCALAR_FIELD(fk_upd_action);
    1881      107588 :     COMPARE_SCALAR_FIELD(fk_del_action);
    1882      107588 :     COMPARE_NODE_FIELD(fk_del_set_cols);
    1883      107588 :     COMPARE_NODE_FIELD(old_conpfeqop);
    1884      107588 :     COMPARE_SCALAR_FIELD(old_pktable_oid);
    1885      107588 :     COMPARE_SCALAR_FIELD(skip_validation);
    1886      107588 :     COMPARE_SCALAR_FIELD(initially_valid);
    1887             : 
    1888      107588 :     return true;
    1889             : }
    1890             : 
    1891             : static bool
    1892         432 : _equalCreateTableSpaceStmt(const CreateTableSpaceStmt *a, const CreateTableSpaceStmt *b)
    1893             : {
    1894         432 :     COMPARE_STRING_FIELD(tablespacename);
    1895         432 :     COMPARE_NODE_FIELD(owner);
    1896         432 :     COMPARE_STRING_FIELD(location);
    1897         432 :     COMPARE_NODE_FIELD(options);
    1898             : 
    1899         432 :     return true;
    1900             : }
    1901             : 
    1902             : static bool
    1903         248 : _equalDropTableSpaceStmt(const DropTableSpaceStmt *a, const DropTableSpaceStmt *b)
    1904             : {
    1905         248 :     COMPARE_STRING_FIELD(tablespacename);
    1906         248 :     COMPARE_SCALAR_FIELD(missing_ok);
    1907             : 
    1908         248 :     return true;
    1909             : }
    1910             : 
    1911             : static bool
    1912          96 : _equalAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *a, const AlterTableSpaceOptionsStmt *b)
    1913             : {
    1914          96 :     COMPARE_STRING_FIELD(tablespacename);
    1915          96 :     COMPARE_NODE_FIELD(options);
    1916          96 :     COMPARE_SCALAR_FIELD(isReset);
    1917             : 
    1918          96 :     return true;
    1919             : }
    1920             : 
    1921             : static bool
    1922         120 : _equalAlterTableMoveAllStmt(const AlterTableMoveAllStmt *a, const AlterTableMoveAllStmt *b)
    1923             : {
    1924         120 :     COMPARE_STRING_FIELD(orig_tablespacename);
    1925         120 :     COMPARE_SCALAR_FIELD(objtype);
    1926         120 :     COMPARE_NODE_FIELD(roles);
    1927         120 :     COMPARE_STRING_FIELD(new_tablespacename);
    1928         120 :     COMPARE_SCALAR_FIELD(nowait);
    1929             : 
    1930         120 :     return true;
    1931             : }
    1932             : 
    1933             : static bool
    1934        1504 : _equalCreateExtensionStmt(const CreateExtensionStmt *a, const CreateExtensionStmt *b)
    1935             : {
    1936        1504 :     COMPARE_STRING_FIELD(extname);
    1937        1504 :     COMPARE_SCALAR_FIELD(if_not_exists);
    1938        1504 :     COMPARE_NODE_FIELD(options);
    1939             : 
    1940        1504 :     return true;
    1941             : }
    1942             : 
    1943             : static bool
    1944         100 : _equalAlterExtensionStmt(const AlterExtensionStmt *a, const AlterExtensionStmt *b)
    1945             : {
    1946         100 :     COMPARE_STRING_FIELD(extname);
    1947         100 :     COMPARE_NODE_FIELD(options);
    1948             : 
    1949         100 :     return true;
    1950             : }
    1951             : 
    1952             : static bool
    1953         712 : _equalAlterExtensionContentsStmt(const AlterExtensionContentsStmt *a, const AlterExtensionContentsStmt *b)
    1954             : {
    1955         712 :     COMPARE_STRING_FIELD(extname);
    1956         712 :     COMPARE_SCALAR_FIELD(action);
    1957         712 :     COMPARE_SCALAR_FIELD(objtype);
    1958         712 :     COMPARE_NODE_FIELD(object);
    1959             : 
    1960         712 :     return true;
    1961             : }
    1962             : 
    1963             : static bool
    1964         744 : _equalCreateFdwStmt(const CreateFdwStmt *a, const CreateFdwStmt *b)
    1965             : {
    1966         744 :     COMPARE_STRING_FIELD(fdwname);
    1967         744 :     COMPARE_NODE_FIELD(func_options);
    1968         744 :     COMPARE_NODE_FIELD(options);
    1969             : 
    1970         744 :     return true;
    1971             : }
    1972             : 
    1973             : static bool
    1974         488 : _equalAlterFdwStmt(const AlterFdwStmt *a, const AlterFdwStmt *b)
    1975             : {
    1976         488 :     COMPARE_STRING_FIELD(fdwname);
    1977         488 :     COMPARE_NODE_FIELD(func_options);
    1978         488 :     COMPARE_NODE_FIELD(options);
    1979             : 
    1980         488 :     return true;
    1981             : }
    1982             : 
    1983             : static bool
    1984        1052 : _equalCreateForeignServerStmt(const CreateForeignServerStmt *a, const CreateForeignServerStmt *b)
    1985             : {
    1986        1052 :     COMPARE_STRING_FIELD(servername);
    1987        1052 :     COMPARE_STRING_FIELD(servertype);
    1988        1052 :     COMPARE_STRING_FIELD(version);
    1989        1052 :     COMPARE_STRING_FIELD(fdwname);
    1990        1052 :     COMPARE_SCALAR_FIELD(if_not_exists);
    1991        1052 :     COMPARE_NODE_FIELD(options);
    1992             : 
    1993        1052 :     return true;
    1994             : }
    1995             : 
    1996             : static bool
    1997         852 : _equalAlterForeignServerStmt(const AlterForeignServerStmt *a, const AlterForeignServerStmt *b)
    1998             : {
    1999         852 :     COMPARE_STRING_FIELD(servername);
    2000         852 :     COMPARE_STRING_FIELD(version);
    2001         852 :     COMPARE_NODE_FIELD(options);
    2002         852 :     COMPARE_SCALAR_FIELD(has_version);
    2003             : 
    2004         852 :     return true;
    2005             : }
    2006             : 
    2007             : static bool
    2008        1640 : _equalCreateForeignTableStmt(const CreateForeignTableStmt *a, const CreateForeignTableStmt *b)
    2009             : {
    2010        1640 :     COMPARE_NODE_FIELD(base.relation);
    2011        1640 :     COMPARE_NODE_FIELD(base.tableElts);
    2012        1640 :     COMPARE_NODE_FIELD(base.inhRelations);
    2013        1640 :     COMPARE_NODE_FIELD(base.partbound);
    2014        1640 :     COMPARE_NODE_FIELD(base.partspec);
    2015        1640 :     COMPARE_NODE_FIELD(base.ofTypename);
    2016        1640 :     COMPARE_NODE_FIELD(base.constraints);
    2017        1640 :     COMPARE_NODE_FIELD(base.nnconstraints);
    2018        1640 :     COMPARE_NODE_FIELD(base.options);
    2019        1640 :     COMPARE_SCALAR_FIELD(base.oncommit);
    2020        1640 :     COMPARE_STRING_FIELD(base.tablespacename);
    2021        1640 :     COMPARE_STRING_FIELD(base.accessMethod);
    2022        1640 :     COMPARE_SCALAR_FIELD(base.if_not_exists);
    2023        1640 :     COMPARE_STRING_FIELD(servername);
    2024        1640 :     COMPARE_NODE_FIELD(options);
    2025             : 
    2026        1640 :     return true;
    2027             : }
    2028             : 
    2029             : static bool
    2030         952 : _equalCreateUserMappingStmt(const CreateUserMappingStmt *a, const CreateUserMappingStmt *b)
    2031             : {
    2032         952 :     COMPARE_NODE_FIELD(user);
    2033         952 :     COMPARE_STRING_FIELD(servername);
    2034         952 :     COMPARE_SCALAR_FIELD(if_not_exists);
    2035         952 :     COMPARE_NODE_FIELD(options);
    2036             : 
    2037         952 :     return true;
    2038             : }
    2039             : 
    2040             : static bool
    2041         440 : _equalAlterUserMappingStmt(const AlterUserMappingStmt *a, const AlterUserMappingStmt *b)
    2042             : {
    2043         440 :     COMPARE_NODE_FIELD(user);
    2044         440 :     COMPARE_STRING_FIELD(servername);
    2045         440 :     COMPARE_NODE_FIELD(options);
    2046             : 
    2047         440 :     return true;
    2048             : }
    2049             : 
    2050             : static bool
    2051         504 : _equalDropUserMappingStmt(const DropUserMappingStmt *a, const DropUserMappingStmt *b)
    2052             : {
    2053         504 :     COMPARE_NODE_FIELD(user);
    2054         504 :     COMPARE_STRING_FIELD(servername);
    2055         504 :     COMPARE_SCALAR_FIELD(missing_ok);
    2056             : 
    2057         504 :     return true;
    2058             : }
    2059             : 
    2060             : static bool
    2061         176 : _equalImportForeignSchemaStmt(const ImportForeignSchemaStmt *a, const ImportForeignSchemaStmt *b)
    2062             : {
    2063         176 :     COMPARE_STRING_FIELD(server_name);
    2064         176 :     COMPARE_STRING_FIELD(remote_schema);
    2065         176 :     COMPARE_STRING_FIELD(local_schema);
    2066         176 :     COMPARE_SCALAR_FIELD(list_type);
    2067         176 :     COMPARE_NODE_FIELD(table_list);
    2068         176 :     COMPARE_NODE_FIELD(options);
    2069             : 
    2070         176 :     return true;
    2071             : }
    2072             : 
    2073             : static bool
    2074        2608 : _equalCreatePolicyStmt(const CreatePolicyStmt *a, const CreatePolicyStmt *b)
    2075             : {
    2076        2608 :     COMPARE_STRING_FIELD(policy_name);
    2077        2608 :     COMPARE_NODE_FIELD(table);
    2078        2608 :     COMPARE_STRING_FIELD(cmd_name);
    2079        2608 :     COMPARE_SCALAR_FIELD(permissive);
    2080        2608 :     COMPARE_NODE_FIELD(roles);
    2081        2608 :     COMPARE_NODE_FIELD(qual);
    2082        2608 :     COMPARE_NODE_FIELD(with_check);
    2083             : 
    2084        2608 :     return true;
    2085             : }
    2086             : 
    2087             : static bool
    2088         336 : _equalAlterPolicyStmt(const AlterPolicyStmt *a, const AlterPolicyStmt *b)
    2089             : {
    2090         336 :     COMPARE_STRING_FIELD(policy_name);
    2091         336 :     COMPARE_NODE_FIELD(table);
    2092         336 :     COMPARE_NODE_FIELD(roles);
    2093         336 :     COMPARE_NODE_FIELD(qual);
    2094         336 :     COMPARE_NODE_FIELD(with_check);
    2095             : 
    2096         336 :     return true;
    2097             : }
    2098             : 
    2099             : static bool
    2100         240 : _equalCreateAmStmt(const CreateAmStmt *a, const CreateAmStmt *b)
    2101             : {
    2102         240 :     COMPARE_STRING_FIELD(amname);
    2103         240 :     COMPARE_NODE_FIELD(handler_name);
    2104         240 :     COMPARE_SCALAR_FIELD(amtype);
    2105             : 
    2106         240 :     return true;
    2107             : }
    2108             : 
    2109             : static bool
    2110       12328 : _equalCreateTrigStmt(const CreateTrigStmt *a, const CreateTrigStmt *b)
    2111             : {
    2112       12328 :     COMPARE_SCALAR_FIELD(replace);
    2113       12328 :     COMPARE_SCALAR_FIELD(isconstraint);
    2114       12328 :     COMPARE_STRING_FIELD(trigname);
    2115       12328 :     COMPARE_NODE_FIELD(relation);
    2116       12328 :     COMPARE_NODE_FIELD(funcname);
    2117       12328 :     COMPARE_NODE_FIELD(args);
    2118       12328 :     COMPARE_SCALAR_FIELD(row);
    2119       12328 :     COMPARE_SCALAR_FIELD(timing);
    2120       12328 :     COMPARE_SCALAR_FIELD(events);
    2121       12328 :     COMPARE_NODE_FIELD(columns);
    2122       12328 :     COMPARE_NODE_FIELD(whenClause);
    2123       12328 :     COMPARE_NODE_FIELD(transitionRels);
    2124       12328 :     COMPARE_SCALAR_FIELD(deferrable);
    2125       12328 :     COMPARE_SCALAR_FIELD(initdeferred);
    2126       12328 :     COMPARE_NODE_FIELD(constrrel);
    2127             : 
    2128       12328 :     return true;
    2129             : }
    2130             : 
    2131             : static bool
    2132         712 : _equalCreateEventTrigStmt(const CreateEventTrigStmt *a, const CreateEventTrigStmt *b)
    2133             : {
    2134         712 :     COMPARE_STRING_FIELD(trigname);
    2135         712 :     COMPARE_STRING_FIELD(eventname);
    2136         712 :     COMPARE_NODE_FIELD(whenclause);
    2137         712 :     COMPARE_NODE_FIELD(funcname);
    2138             : 
    2139         712 :     return true;
    2140             : }
    2141             : 
    2142             : static bool
    2143         168 : _equalAlterEventTrigStmt(const AlterEventTrigStmt *a, const AlterEventTrigStmt *b)
    2144             : {
    2145         168 :     COMPARE_STRING_FIELD(trigname);
    2146         168 :     COMPARE_SCALAR_FIELD(tgenabled);
    2147             : 
    2148         168 :     return true;
    2149             : }
    2150             : 
    2151             : static bool
    2152         424 : _equalCreatePLangStmt(const CreatePLangStmt *a, const CreatePLangStmt *b)
    2153             : {
    2154         424 :     COMPARE_SCALAR_FIELD(replace);
    2155         424 :     COMPARE_STRING_FIELD(plname);
    2156         424 :     COMPARE_NODE_FIELD(plhandler);
    2157         424 :     COMPARE_NODE_FIELD(plinline);
    2158         424 :     COMPARE_NODE_FIELD(plvalidator);
    2159         424 :     COMPARE_SCALAR_FIELD(pltrusted);
    2160             : 
    2161         424 :     return true;
    2162             : }
    2163             : 
    2164             : static bool
    2165        6576 : _equalCreateRoleStmt(const CreateRoleStmt *a, const CreateRoleStmt *b)
    2166             : {
    2167        6576 :     COMPARE_SCALAR_FIELD(stmt_type);
    2168        6576 :     COMPARE_STRING_FIELD(role);
    2169        6576 :     COMPARE_NODE_FIELD(options);
    2170             : 
    2171        6576 :     return true;
    2172             : }
    2173             : 
    2174             : static bool
    2175        1680 : _equalAlterRoleStmt(const AlterRoleStmt *a, const AlterRoleStmt *b)
    2176             : {
    2177        1680 :     COMPARE_NODE_FIELD(role);
    2178        1680 :     COMPARE_NODE_FIELD(options);
    2179        1680 :     COMPARE_SCALAR_FIELD(action);
    2180             : 
    2181        1680 :     return true;
    2182             : }
    2183             : 
    2184             : static bool
    2185         312 : _equalAlterRoleSetStmt(const AlterRoleSetStmt *a, const AlterRoleSetStmt *b)
    2186             : {
    2187         312 :     COMPARE_NODE_FIELD(role);
    2188         312 :     COMPARE_STRING_FIELD(database);
    2189         312 :     COMPARE_NODE_FIELD(setstmt);
    2190             : 
    2191         312 :     return true;
    2192             : }
    2193             : 
    2194             : static bool
    2195        6424 : _equalDropRoleStmt(const DropRoleStmt *a, const DropRoleStmt *b)
    2196             : {
    2197        6424 :     COMPARE_NODE_FIELD(roles);
    2198        6424 :     COMPARE_SCALAR_FIELD(missing_ok);
    2199             : 
    2200        6424 :     return true;
    2201             : }
    2202             : 
    2203             : static bool
    2204        2536 : _equalCreateSeqStmt(const CreateSeqStmt *a, const CreateSeqStmt *b)
    2205             : {
    2206        2536 :     COMPARE_NODE_FIELD(sequence);
    2207        2536 :     COMPARE_NODE_FIELD(options);
    2208        2536 :     COMPARE_SCALAR_FIELD(ownerId);
    2209        2536 :     COMPARE_SCALAR_FIELD(for_identity);
    2210        2536 :     COMPARE_SCALAR_FIELD(if_not_exists);
    2211             : 
    2212        2536 :     return true;
    2213             : }
    2214             : 
    2215             : static bool
    2216         784 : _equalAlterSeqStmt(const AlterSeqStmt *a, const AlterSeqStmt *b)
    2217             : {
    2218         784 :     COMPARE_NODE_FIELD(sequence);
    2219         784 :     COMPARE_NODE_FIELD(options);
    2220         784 :     COMPARE_SCALAR_FIELD(for_identity);
    2221         784 :     COMPARE_SCALAR_FIELD(missing_ok);
    2222             : 
    2223         784 :     return true;
    2224             : }
    2225             : 
    2226             : static bool
    2227       27000 : _equalDefineStmt(const DefineStmt *a, const DefineStmt *b)
    2228             : {
    2229       27000 :     COMPARE_SCALAR_FIELD(kind);
    2230       27000 :     COMPARE_SCALAR_FIELD(oldstyle);
    2231       27000 :     COMPARE_NODE_FIELD(defnames);
    2232       27000 :     COMPARE_NODE_FIELD(args);
    2233       27000 :     COMPARE_NODE_FIELD(definition);
    2234       27000 :     COMPARE_SCALAR_FIELD(if_not_exists);
    2235       27000 :     COMPARE_SCALAR_FIELD(replace);
    2236             : 
    2237       27000 :     return true;
    2238             : }
    2239             : 
    2240             : static bool
    2241        3840 : _equalCreateDomainStmt(const CreateDomainStmt *a, const CreateDomainStmt *b)
    2242             : {
    2243        3840 :     COMPARE_NODE_FIELD(domainname);
    2244        3840 :     COMPARE_NODE_FIELD(typeName);
    2245        3840 :     COMPARE_NODE_FIELD(collClause);
    2246        3840 :     COMPARE_NODE_FIELD(constraints);
    2247             : 
    2248        3840 :     return true;
    2249             : }
    2250             : 
    2251             : static bool
    2252        1512 : _equalCreateOpClassStmt(const CreateOpClassStmt *a, const CreateOpClassStmt *b)
    2253             : {
    2254        1512 :     COMPARE_NODE_FIELD(opclassname);
    2255        1512 :     COMPARE_NODE_FIELD(opfamilyname);
    2256        1512 :     COMPARE_STRING_FIELD(amname);
    2257        1512 :     COMPARE_NODE_FIELD(datatype);
    2258        1512 :     COMPARE_NODE_FIELD(items);
    2259        1512 :     COMPARE_SCALAR_FIELD(isDefault);
    2260             : 
    2261        1512 :     return true;
    2262             : }
    2263             : 
    2264             : static bool
    2265       15632 : _equalCreateOpClassItem(const CreateOpClassItem *a, const CreateOpClassItem *b)
    2266             : {
    2267       15632 :     COMPARE_SCALAR_FIELD(itemtype);
    2268       15632 :     COMPARE_NODE_FIELD(name);
    2269       15632 :     COMPARE_SCALAR_FIELD(number);
    2270       15632 :     COMPARE_NODE_FIELD(order_family);
    2271       15632 :     COMPARE_NODE_FIELD(class_args);
    2272       15632 :     COMPARE_NODE_FIELD(storedtype);
    2273             : 
    2274       15632 :     return true;
    2275             : }
    2276             : 
    2277             : static bool
    2278         592 : _equalCreateOpFamilyStmt(const CreateOpFamilyStmt *a, const CreateOpFamilyStmt *b)
    2279             : {
    2280         592 :     COMPARE_NODE_FIELD(opfamilyname);
    2281         592 :     COMPARE_STRING_FIELD(amname);
    2282             : 
    2283         592 :     return true;
    2284             : }
    2285             : 
    2286             : static bool
    2287        1800 : _equalAlterOpFamilyStmt(const AlterOpFamilyStmt *a, const AlterOpFamilyStmt *b)
    2288             : {
    2289        1800 :     COMPARE_NODE_FIELD(opfamilyname);
    2290        1800 :     COMPARE_STRING_FIELD(amname);
    2291        1800 :     COMPARE_SCALAR_FIELD(isDrop);
    2292        1800 :     COMPARE_NODE_FIELD(items);
    2293             : 
    2294        1800 :     return true;
    2295             : }
    2296             : 
    2297             : static bool
    2298       91620 : _equalDropStmt(const DropStmt *a, const DropStmt *b)
    2299             : {
    2300       91620 :     COMPARE_NODE_FIELD(objects);
    2301       91620 :     COMPARE_SCALAR_FIELD(removeType);
    2302       91620 :     COMPARE_SCALAR_FIELD(behavior);
    2303       91620 :     COMPARE_SCALAR_FIELD(missing_ok);
    2304       91620 :     COMPARE_SCALAR_FIELD(concurrent);
    2305             : 
    2306       91620 :     return true;
    2307             : }
    2308             : 
    2309             : static bool
    2310        5396 : _equalTruncateStmt(const TruncateStmt *a, const TruncateStmt *b)
    2311             : {
    2312        5396 :     COMPARE_NODE_FIELD(relations);
    2313        5396 :     COMPARE_SCALAR_FIELD(restart_seqs);
    2314        5396 :     COMPARE_SCALAR_FIELD(behavior);
    2315             : 
    2316        5396 :     return true;
    2317             : }
    2318             : 
    2319             : static bool
    2320       18256 : _equalCommentStmt(const CommentStmt *a, const CommentStmt *b)
    2321             : {
    2322       18256 :     COMPARE_SCALAR_FIELD(objtype);
    2323       18256 :     COMPARE_NODE_FIELD(object);
    2324       18256 :     COMPARE_STRING_FIELD(comment);
    2325             : 
    2326       18256 :     return true;
    2327             : }
    2328             : 
    2329             : static bool
    2330         400 : _equalSecLabelStmt(const SecLabelStmt *a, const SecLabelStmt *b)
    2331             : {
    2332         400 :     COMPARE_SCALAR_FIELD(objtype);
    2333         400 :     COMPARE_NODE_FIELD(object);
    2334         400 :     COMPARE_STRING_FIELD(provider);
    2335         400 :     COMPARE_STRING_FIELD(label);
    2336             : 
    2337         400 :     return true;
    2338             : }
    2339             : 
    2340             : static bool
    2341       11316 : _equalDeclareCursorStmt(const DeclareCursorStmt *a, const DeclareCursorStmt *b)
    2342             : {
    2343       11316 :     COMPARE_STRING_FIELD(portalname);
    2344       11316 :     COMPARE_SCALAR_FIELD(options);
    2345       11316 :     COMPARE_NODE_FIELD(query);
    2346             : 
    2347       11316 :     return true;
    2348             : }
    2349             : 
    2350             : static bool
    2351        8736 : _equalClosePortalStmt(const ClosePortalStmt *a, const ClosePortalStmt *b)
    2352             : {
    2353        8736 :     COMPARE_STRING_FIELD(portalname);
    2354             : 
    2355        8736 :     return true;
    2356             : }
    2357             : 
    2358             : static bool
    2359       23832 : _equalFetchStmt(const FetchStmt *a, const FetchStmt *b)
    2360             : {
    2361       23832 :     COMPARE_SCALAR_FIELD(direction);
    2362       23832 :     COMPARE_SCALAR_FIELD(howMany);
    2363       23832 :     COMPARE_STRING_FIELD(portalname);
    2364       23832 :     COMPARE_SCALAR_FIELD(ismove);
    2365             : 
    2366       23832 :     return true;
    2367             : }
    2368             : 
    2369             : static bool
    2370       22584 : _equalIndexStmt(const IndexStmt *a, const IndexStmt *b)
    2371             : {
    2372       22584 :     COMPARE_STRING_FIELD(idxname);
    2373       22584 :     COMPARE_NODE_FIELD(relation);
    2374       22584 :     COMPARE_STRING_FIELD(accessMethod);
    2375       22584 :     COMPARE_STRING_FIELD(tableSpace);
    2376       22584 :     COMPARE_NODE_FIELD(indexParams);
    2377       22584 :     COMPARE_NODE_FIELD(indexIncludingParams);
    2378       22584 :     COMPARE_NODE_FIELD(options);
    2379       22584 :     COMPARE_NODE_FIELD(whereClause);
    2380       22584 :     COMPARE_NODE_FIELD(excludeOpNames);
    2381       22584 :     COMPARE_STRING_FIELD(idxcomment);
    2382       22584 :     COMPARE_SCALAR_FIELD(indexOid);
    2383       22584 :     COMPARE_SCALAR_FIELD(oldNumber);
    2384       22584 :     COMPARE_SCALAR_FIELD(oldCreateSubid);
    2385       22584 :     COMPARE_SCALAR_FIELD(oldFirstRelfilelocatorSubid);
    2386       22584 :     COMPARE_SCALAR_FIELD(unique);
    2387       22584 :     COMPARE_SCALAR_FIELD(nulls_not_distinct);
    2388       22584 :     COMPARE_SCALAR_FIELD(primary);
    2389       22584 :     COMPARE_SCALAR_FIELD(isconstraint);
    2390       22584 :     COMPARE_SCALAR_FIELD(deferrable);
    2391       22584 :     COMPARE_SCALAR_FIELD(initdeferred);
    2392       22584 :     COMPARE_SCALAR_FIELD(transformed);
    2393       22584 :     COMPARE_SCALAR_FIELD(concurrent);
    2394       22584 :     COMPARE_SCALAR_FIELD(if_not_exists);
    2395       22584 :     COMPARE_SCALAR_FIELD(reset_default_tblspc);
    2396             : 
    2397       22584 :     return true;
    2398             : }
    2399             : 
    2400             : static bool
    2401        2172 : _equalCreateStatsStmt(const CreateStatsStmt *a, const CreateStatsStmt *b)
    2402             : {
    2403        2172 :     COMPARE_NODE_FIELD(defnames);
    2404        2172 :     COMPARE_NODE_FIELD(stat_types);
    2405        2172 :     COMPARE_NODE_FIELD(exprs);
    2406        2172 :     COMPARE_NODE_FIELD(relations);
    2407        2172 :     COMPARE_STRING_FIELD(stxcomment);
    2408        2172 :     COMPARE_SCALAR_FIELD(transformed);
    2409        2172 :     COMPARE_SCALAR_FIELD(if_not_exists);
    2410             : 
    2411        2172 :     return true;
    2412             : }
    2413             : 
    2414             : static bool
    2415        5696 : _equalStatsElem(const StatsElem *a, const StatsElem *b)
    2416             : {
    2417        5696 :     COMPARE_STRING_FIELD(name);
    2418        5696 :     COMPARE_NODE_FIELD(expr);
    2419             : 
    2420        5696 :     return true;
    2421             : }
    2422             : 
    2423             : static bool
    2424         104 : _equalAlterStatsStmt(const AlterStatsStmt *a, const AlterStatsStmt *b)
    2425             : {
    2426         104 :     COMPARE_NODE_FIELD(defnames);
    2427         104 :     COMPARE_SCALAR_FIELD(stxstattarget);
    2428         104 :     COMPARE_SCALAR_FIELD(missing_ok);
    2429             : 
    2430         104 :     return true;
    2431             : }
    2432             : 
    2433             : static bool
    2434       74920 : _equalCreateFunctionStmt(const CreateFunctionStmt *a, const CreateFunctionStmt *b)
    2435             : {
    2436       74920 :     COMPARE_SCALAR_FIELD(is_procedure);
    2437       74920 :     COMPARE_SCALAR_FIELD(replace);
    2438       74920 :     COMPARE_NODE_FIELD(funcname);
    2439       74920 :     COMPARE_NODE_FIELD(parameters);
    2440       74920 :     COMPARE_NODE_FIELD(returnType);
    2441       74920 :     COMPARE_NODE_FIELD(options);
    2442       74920 :     COMPARE_NODE_FIELD(sql_body);
    2443             : 
    2444       74920 :     return true;
    2445             : }
    2446             : 
    2447             : static bool
    2448      218808 : _equalFunctionParameter(const FunctionParameter *a, const FunctionParameter *b)
    2449             : {
    2450      218808 :     COMPARE_STRING_FIELD(name);
    2451      218808 :     COMPARE_NODE_FIELD(argType);
    2452      218808 :     COMPARE_SCALAR_FIELD(mode);
    2453      218808 :     COMPARE_NODE_FIELD(defexpr);
    2454             : 
    2455      218808 :     return true;
    2456             : }
    2457             : 
    2458             : static bool
    2459        2528 : _equalAlterFunctionStmt(const AlterFunctionStmt *a, const AlterFunctionStmt *b)
    2460             : {
    2461        2528 :     COMPARE_SCALAR_FIELD(objtype);
    2462        2528 :     COMPARE_NODE_FIELD(func);
    2463        2528 :     COMPARE_NODE_FIELD(actions);
    2464             : 
    2465        2528 :     return true;
    2466             : }
    2467             : 
    2468             : static bool
    2469        3896 : _equalDoStmt(const DoStmt *a, const DoStmt *b)
    2470             : {
    2471        3896 :     COMPARE_NODE_FIELD(args);
    2472             : 
    2473        3896 :     return true;
    2474             : }
    2475             : 
    2476             : static bool
    2477        1504 : _equalCallStmt(const CallStmt *a, const CallStmt *b)
    2478             : {
    2479        1504 :     COMPARE_NODE_FIELD(funccall);
    2480        1504 :     COMPARE_NODE_FIELD(funcexpr);
    2481        1504 :     COMPARE_NODE_FIELD(outargs);
    2482             : 
    2483        1504 :     return true;
    2484             : }
    2485             : 
    2486             : static bool
    2487        5400 : _equalRenameStmt(const RenameStmt *a, const RenameStmt *b)
    2488             : {
    2489        5400 :     COMPARE_SCALAR_FIELD(renameType);
    2490        5400 :     COMPARE_SCALAR_FIELD(relationType);
    2491        5400 :     COMPARE_NODE_FIELD(relation);
    2492        5400 :     COMPARE_NODE_FIELD(object);
    2493        5400 :     COMPARE_STRING_FIELD(subname);
    2494        5400 :     COMPARE_STRING_FIELD(newname);
    2495        5400 :     COMPARE_SCALAR_FIELD(behavior);
    2496        5400 :     COMPARE_SCALAR_FIELD(missing_ok);
    2497             : 
    2498        5400 :     return true;
    2499             : }
    2500             : 
    2501             : static bool
    2502         184 : _equalAlterObjectDependsStmt(const AlterObjectDependsStmt *a, const AlterObjectDependsStmt *b)
    2503             : {
    2504         184 :     COMPARE_SCALAR_FIELD(objectType);
    2505         184 :     COMPARE_NODE_FIELD(relation);
    2506         184 :     COMPARE_NODE_FIELD(object);
    2507         184 :     COMPARE_NODE_FIELD(extname);
    2508         184 :     COMPARE_SCALAR_FIELD(remove);
    2509             : 
    2510         184 :     return true;
    2511             : }
    2512             : 
    2513             : static bool
    2514        1544 : _equalAlterObjectSchemaStmt(const AlterObjectSchemaStmt *a, const AlterObjectSchemaStmt *b)
    2515             : {
    2516        1544 :     COMPARE_SCALAR_FIELD(objectType);
    2517        1544 :     COMPARE_NODE_FIELD(relation);
    2518        1544 :     COMPARE_NODE_FIELD(object);
    2519        1544 :     COMPARE_STRING_FIELD(newschema);
    2520        1544 :     COMPARE_SCALAR_FIELD(missing_ok);
    2521             : 
    2522        1544 :     return true;
    2523             : }
    2524             : 
    2525             : static bool
    2526        5900 : _equalAlterOwnerStmt(const AlterOwnerStmt *a, const AlterOwnerStmt *b)
    2527             : {
    2528        5900 :     COMPARE_SCALAR_FIELD(objectType);
    2529        5900 :     COMPARE_NODE_FIELD(relation);
    2530        5900 :     COMPARE_NODE_FIELD(object);
    2531        5900 :     COMPARE_NODE_FIELD(newowner);
    2532             : 
    2533        5900 :     return true;
    2534             : }
    2535             : 
    2536             : static bool
    2537        2392 : _equalAlterOperatorStmt(const AlterOperatorStmt *a, const AlterOperatorStmt *b)
    2538             : {
    2539        2392 :     COMPARE_NODE_FIELD(opername);
    2540        2392 :     COMPARE_NODE_FIELD(options);
    2541             : 
    2542        2392 :     return true;
    2543             : }
    2544             : 
    2545             : static bool
    2546         240 : _equalAlterTypeStmt(const AlterTypeStmt *a, const AlterTypeStmt *b)
    2547             : {
    2548         240 :     COMPARE_NODE_FIELD(typeName);
    2549         240 :     COMPARE_NODE_FIELD(options);
    2550             : 
    2551         240 :     return true;
    2552             : }
    2553             : 
    2554             : static bool
    2555        3936 : _equalRuleStmt(const RuleStmt *a, const RuleStmt *b)
    2556             : {
    2557        3936 :     COMPARE_NODE_FIELD(relation);
    2558        3936 :     COMPARE_STRING_FIELD(rulename);
    2559        3936 :     COMPARE_NODE_FIELD(whereClause);
    2560        3936 :     COMPARE_SCALAR_FIELD(event);
    2561        3936 :     COMPARE_SCALAR_FIELD(instead);
    2562        3936 :     COMPARE_NODE_FIELD(actions);
    2563        3936 :     COMPARE_SCALAR_FIELD(replace);
    2564             : 
    2565        3936 :     return true;
    2566             : }
    2567             : 
    2568             : static bool
    2569         502 : _equalNotifyStmt(const NotifyStmt *a, const NotifyStmt *b)
    2570             : {
    2571         502 :     COMPARE_STRING_FIELD(conditionname);
    2572         502 :     COMPARE_STRING_FIELD(payload);
    2573             : 
    2574         502 :     return true;
    2575             : }
    2576             : 
    2577             : static bool
    2578         296 : _equalListenStmt(const ListenStmt *a, const ListenStmt *b)
    2579             : {
    2580         296 :     COMPARE_STRING_FIELD(conditionname);
    2581             : 
    2582         296 :     return true;
    2583             : }
    2584             : 
    2585             : static bool
    2586         152 : _equalUnlistenStmt(const UnlistenStmt *a, const UnlistenStmt *b)
    2587             : {
    2588         152 :     COMPARE_STRING_FIELD(conditionname);
    2589             : 
    2590         152 :     return true;
    2591             : }
    2592             : 
    2593             : static bool
    2594      134340 : _equalTransactionStmt(const TransactionStmt *a, const TransactionStmt *b)
    2595             : {
    2596      134340 :     COMPARE_SCALAR_FIELD(kind);
    2597      134340 :     COMPARE_NODE_FIELD(options);
    2598      134340 :     COMPARE_STRING_FIELD(savepoint_name);
    2599      134340 :     COMPARE_STRING_FIELD(gid);
    2600      134340 :     COMPARE_SCALAR_FIELD(chain);
    2601             :     COMPARE_LOCATION_FIELD(location);
    2602             : 
    2603      134340 :     return true;
    2604             : }
    2605             : 
    2606             : static bool
    2607        2504 : _equalCompositeTypeStmt(const CompositeTypeStmt *a, const CompositeTypeStmt *b)
    2608             : {
    2609        2504 :     COMPARE_NODE_FIELD(typevar);
    2610        2504 :     COMPARE_NODE_FIELD(coldeflist);
    2611             : 
    2612        2504 :     return true;
    2613             : }
    2614             : 
    2615             : static bool
    2616         712 : _equalCreateEnumStmt(const CreateEnumStmt *a, const CreateEnumStmt *b)
    2617             : {
    2618         712 :     COMPARE_NODE_FIELD(typeName);
    2619         712 :     COMPARE_NODE_FIELD(vals);
    2620             : 
    2621         712 :     return true;
    2622             : }
    2623             : 
    2624             : static bool
    2625         528 : _equalCreateRangeStmt(const CreateRangeStmt *a, const CreateRangeStmt *b)
    2626             : {
    2627         528 :     COMPARE_NODE_FIELD(typeName);
    2628         528 :     COMPARE_NODE_FIELD(params);
    2629             : 
    2630         528 :     return true;
    2631             : }
    2632             : 
    2633             : static bool
    2634        1528 : _equalAlterEnumStmt(const AlterEnumStmt *a, const AlterEnumStmt *b)
    2635             : {
    2636        1528 :     COMPARE_NODE_FIELD(typeName);
    2637        1528 :     COMPARE_STRING_FIELD(oldVal);
    2638        1528 :     COMPARE_STRING_FIELD(newVal);
    2639        1528 :     COMPARE_STRING_FIELD(newValNeighbor);
    2640        1528 :     COMPARE_SCALAR_FIELD(newValIsAfter);
    2641        1528 :     COMPARE_SCALAR_FIELD(skipIfNewValExists);
    2642             : 
    2643        1528 :     return true;
    2644             : }
    2645             : 
    2646             : static bool
    2647       45152 : _equalViewStmt(const ViewStmt *a, const ViewStmt *b)
    2648             : {
    2649       45152 :     COMPARE_NODE_FIELD(view);
    2650       45152 :     COMPARE_NODE_FIELD(aliases);
    2651       45152 :     COMPARE_NODE_FIELD(query);
    2652       45152 :     COMPARE_SCALAR_FIELD(replace);
    2653       45152 :     COMPARE_NODE_FIELD(options);
    2654       45152 :     COMPARE_SCALAR_FIELD(withCheckOption);
    2655             : 
    2656       45152 :     return true;
    2657             : }
    2658             : 
    2659             : static bool
    2660         232 : _equalLoadStmt(const LoadStmt *a, const LoadStmt *b)
    2661             : {
    2662         232 :     COMPARE_STRING_FIELD(filename);
    2663             : 
    2664         232 :     return true;
    2665             : }
    2666             : 
    2667             : static bool
    2668        2232 : _equalCreatedbStmt(const CreatedbStmt *a, const CreatedbStmt *b)
    2669             : {
    2670        2232 :     COMPARE_STRING_FIELD(dbname);
    2671        2232 :     COMPARE_NODE_FIELD(options);
    2672             : 
    2673        2232 :     return true;
    2674             : }
    2675             : 
    2676             : static bool
    2677         112 : _equalAlterDatabaseStmt(const AlterDatabaseStmt *a, const AlterDatabaseStmt *b)
    2678             : {
    2679         112 :     COMPARE_STRING_FIELD(dbname);
    2680         112 :     COMPARE_NODE_FIELD(options);
    2681             : 
    2682         112 :     return true;
    2683             : }
    2684             : 
    2685             : static bool
    2686           8 : _equalAlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt *a, const AlterDatabaseRefreshCollStmt *b)
    2687             : {
    2688           8 :     COMPARE_STRING_FIELD(dbname);
    2689             : 
    2690           8 :     return true;
    2691             : }
    2692             : 
    2693             : static bool
    2694        4128 : _equalAlterDatabaseSetStmt(const AlterDatabaseSetStmt *a, const AlterDatabaseSetStmt *b)
    2695             : {
    2696        4128 :     COMPARE_STRING_FIELD(dbname);
    2697        4128 :     COMPARE_NODE_FIELD(setstmt);
    2698             : 
    2699        4128 :     return true;
    2700             : }
    2701             : 
    2702             : static bool
    2703         344 : _equalDropdbStmt(const DropdbStmt *a, const DropdbStmt *b)
    2704             : {
    2705         344 :     COMPARE_STRING_FIELD(dbname);
    2706         344 :     COMPARE_SCALAR_FIELD(missing_ok);
    2707         344 :     COMPARE_NODE_FIELD(options);
    2708             : 
    2709         344 :     return true;
    2710             : }
    2711             : 
    2712             : static bool
    2713         616 : _equalAlterSystemStmt(const AlterSystemStmt *a, const AlterSystemStmt *b)
    2714             : {
    2715         616 :     COMPARE_NODE_FIELD(setstmt);
    2716             : 
    2717         616 :     return true;
    2718             : }
    2719             : 
    2720             : static bool
    2721         816 : _equalClusterStmt(const ClusterStmt *a, const ClusterStmt *b)
    2722             : {
    2723         816 :     COMPARE_NODE_FIELD(relation);
    2724         816 :     COMPARE_STRING_FIELD(indexname);
    2725         816 :     COMPARE_NODE_FIELD(params);
    2726             : 
    2727         816 :     return true;
    2728             : }
    2729             : 
    2730             : static bool
    2731       37372 : _equalVacuumStmt(const VacuumStmt *a, const VacuumStmt *b)
    2732             : {
    2733       37372 :     COMPARE_NODE_FIELD(options);
    2734       37372 :     COMPARE_NODE_FIELD(rels);
    2735       37372 :     COMPARE_SCALAR_FIELD(is_vacuumcmd);
    2736             : 
    2737       37372 :     return true;
    2738             : }
    2739             : 
    2740             : static bool
    2741       37012 : _equalVacuumRelation(const VacuumRelation *a, const VacuumRelation *b)
    2742             : {
    2743       37012 :     COMPARE_NODE_FIELD(relation);
    2744       37012 :     COMPARE_SCALAR_FIELD(oid);
    2745       37012 :     COMPARE_NODE_FIELD(va_cols);
    2746             : 
    2747       37012 :     return true;
    2748             : }
    2749             : 
    2750             : static bool
    2751       66856 : _equalExplainStmt(const ExplainStmt *a, const ExplainStmt *b)
    2752             : {
    2753       66856 :     COMPARE_NODE_FIELD(query);
    2754       66856 :     COMPARE_NODE_FIELD(options);
    2755             : 
    2756       66856 :     return true;
    2757             : }
    2758             : 
    2759             : static bool
    2760        7132 : _equalCreateTableAsStmt(const CreateTableAsStmt *a, const CreateTableAsStmt *b)
    2761             : {
    2762        7132 :     COMPARE_NODE_FIELD(query);
    2763        7132 :     COMPARE_NODE_FIELD(into);
    2764        7132 :     COMPARE_SCALAR_FIELD(objtype);
    2765        7132 :     COMPARE_SCALAR_FIELD(is_select_into);
    2766        7132 :     COMPARE_SCALAR_FIELD(if_not_exists);
    2767             : 
    2768        7132 :     return true;
    2769             : }
    2770             : 
    2771             : static bool
    2772         912 : _equalRefreshMatViewStmt(const RefreshMatViewStmt *a, const RefreshMatViewStmt *b)
    2773             : {
    2774         912 :     COMPARE_SCALAR_FIELD(concurrent);
    2775         912 :     COMPARE_SCALAR_FIELD(skipData);
    2776         912 :     COMPARE_NODE_FIELD(relation);
    2777             : 
    2778         912 :     return true;
    2779             : }
    2780             : 
    2781             : static bool
    2782         672 : _equalCheckPointStmt(const CheckPointStmt *a, const CheckPointStmt *b)
    2783             : {
    2784             : 
    2785         672 :     return true;
    2786             : }
    2787             : 
    2788             : static bool
    2789         120 : _equalDiscardStmt(const DiscardStmt *a, const DiscardStmt *b)
    2790             : {
    2791         120 :     COMPARE_SCALAR_FIELD(target);
    2792             : 
    2793         120 :     return true;
    2794             : }
    2795             : 
    2796             : static bool
    2797        3952 : _equalLockStmt(const LockStmt *a, const LockStmt *b)
    2798             : {
    2799        3952 :     COMPARE_NODE_FIELD(relations);
    2800        3952 :     COMPARE_SCALAR_FIELD(mode);
    2801        3952 :     COMPARE_SCALAR_FIELD(nowait);
    2802             : 
    2803        3952 :     return true;
    2804             : }
    2805             : 
    2806             : static bool
    2807         404 : _equalConstraintsSetStmt(const ConstraintsSetStmt *a, const ConstraintsSetStmt *b)
    2808             : {
    2809         404 :     COMPARE_NODE_FIELD(constraints);
    2810         404 :     COMPARE_SCALAR_FIELD(deferred);
    2811             : 
    2812         404 :     return true;
    2813             : }
    2814             : 
    2815             : static bool
    2816        3296 : _equalReindexStmt(const ReindexStmt *a, const ReindexStmt *b)
    2817             : {
    2818        3296 :     COMPARE_SCALAR_FIELD(kind);
    2819        3296 :     COMPARE_NODE_FIELD(relation);
    2820        3296 :     COMPARE_STRING_FIELD(name);
    2821        3296 :     COMPARE_NODE_FIELD(params);
    2822             : 
    2823        3296 :     return true;
    2824             : }
    2825             : 
    2826             : static bool
    2827         256 : _equalCreateConversionStmt(const CreateConversionStmt *a, const CreateConversionStmt *b)
    2828             : {
    2829         256 :     COMPARE_NODE_FIELD(conversion_name);
    2830         256 :     COMPARE_STRING_FIELD(for_encoding_name);
    2831         256 :     COMPARE_STRING_FIELD(to_encoding_name);
    2832         256 :     COMPARE_NODE_FIELD(func_name);
    2833         256 :     COMPARE_SCALAR_FIELD(def);
    2834             : 
    2835         256 :     return true;
    2836             : }
    2837             : 
    2838             : static bool
    2839        1080 : _equalCreateCastStmt(const CreateCastStmt *a, const CreateCastStmt *b)
    2840             : {
    2841        1080 :     COMPARE_NODE_FIELD(sourcetype);
    2842        1080 :     COMPARE_NODE_FIELD(targettype);
    2843        1080 :     COMPARE_NODE_FIELD(func);
    2844        1080 :     COMPARE_SCALAR_FIELD(context);
    2845        1080 :     COMPARE_SCALAR_FIELD(inout);
    2846             : 
    2847        1080 :     return true;
    2848             : }
    2849             : 
    2850             : static bool
    2851         200 : _equalCreateTransformStmt(const CreateTransformStmt *a, const CreateTransformStmt *b)
    2852             : {
    2853         200 :     COMPARE_SCALAR_FIELD(replace);
    2854         200 :     COMPARE_NODE_FIELD(type_name);
    2855         200 :     COMPARE_STRING_FIELD(lang);
    2856         200 :     COMPARE_NODE_FIELD(fromsql);
    2857         200 :     COMPARE_NODE_FIELD(tosql);
    2858             : 
    2859         200 :     return true;
    2860             : }
    2861             : 
    2862             : static bool
    2863        6456 : _equalPrepareStmt(const PrepareStmt *a, const PrepareStmt *b)
    2864             : {
    2865        6456 :     COMPARE_STRING_FIELD(name);
    2866        6456 :     COMPARE_NODE_FIELD(argtypes);
    2867        6456 :     COMPARE_NODE_FIELD(query);
    2868             : 
    2869        6456 :     return true;
    2870             : }
    2871             : 
    2872             : static bool
    2873       45728 : _equalExecuteStmt(const ExecuteStmt *a, const ExecuteStmt *b)
    2874             : {
    2875       45728 :     COMPARE_STRING_FIELD(name);
    2876       45728 :     COMPARE_NODE_FIELD(params);
    2877             : 
    2878       45728 :     return true;
    2879             : }
    2880             : 
    2881             : static bool
    2882       16136 : _equalDeallocateStmt(const DeallocateStmt *a, const DeallocateStmt *b)
    2883             : {
    2884       16136 :     COMPARE_STRING_FIELD(name);
    2885       16136 :     COMPARE_SCALAR_FIELD(isall);
    2886             :     COMPARE_LOCATION_FIELD(location);
    2887             : 
    2888       16136 :     return true;
    2889             : }
    2890             : 
    2891             : static bool
    2892         576 : _equalDropOwnedStmt(const DropOwnedStmt *a, const DropOwnedStmt *b)
    2893             : {
    2894         576 :     COMPARE_NODE_FIELD(roles);
    2895         576 :     COMPARE_SCALAR_FIELD(behavior);
    2896             : 
    2897         576 :     return true;
    2898             : }
    2899             : 
    2900             : static bool
    2901         152 : _equalReassignOwnedStmt(const ReassignOwnedStmt *a, const ReassignOwnedStmt *b)
    2902             : {
    2903         152 :     COMPARE_NODE_FIELD(roles);
    2904         152 :     COMPARE_NODE_FIELD(newrole);
    2905             : 
    2906         152 :     return true;
    2907             : }
    2908             : 
    2909             : static bool
    2910         160 : _equalAlterTSDictionaryStmt(const AlterTSDictionaryStmt *a, const AlterTSDictionaryStmt *b)
    2911             : {
    2912         160 :     COMPARE_NODE_FIELD(dictname);
    2913         160 :     COMPARE_NODE_FIELD(options);
    2914             : 
    2915         160 :     return true;
    2916             : }
    2917             : 
    2918             : static bool
    2919       20928 : _equalAlterTSConfigurationStmt(const AlterTSConfigurationStmt *a, const AlterTSConfigurationStmt *b)
    2920             : {
    2921       20928 :     COMPARE_SCALAR_FIELD(kind);
    2922       20928 :     COMPARE_NODE_FIELD(cfgname);
    2923       20928 :     COMPARE_NODE_FIELD(tokentype);
    2924       20928 :     COMPARE_NODE_FIELD(dicts);
    2925       20928 :     COMPARE_SCALAR_FIELD(override);
    2926       20928 :     COMPARE_SCALAR_FIELD(replace);
    2927       20928 :     COMPARE_SCALAR_FIELD(missing_ok);
    2928             : 
    2929       20928 :     return true;
    2930             : }
    2931             : 
    2932             : static bool
    2933        5016 : _equalPublicationTable(const PublicationTable *a, const PublicationTable *b)
    2934             : {
    2935        5016 :     COMPARE_NODE_FIELD(relation);
    2936        5016 :     COMPARE_NODE_FIELD(whereClause);
    2937        5016 :     COMPARE_NODE_FIELD(columns);
    2938             : 
    2939        5016 :     return true;
    2940             : }
    2941             : 
    2942             : static bool
    2943        6440 : _equalPublicationObjSpec(const PublicationObjSpec *a, const PublicationObjSpec *b)
    2944             : {
    2945        6440 :     COMPARE_SCALAR_FIELD(pubobjtype);
    2946        6440 :     COMPARE_STRING_FIELD(name);
    2947        6440 :     COMPARE_NODE_FIELD(pubtable);
    2948             :     COMPARE_LOCATION_FIELD(location);
    2949             : 
    2950        6440 :     return true;
    2951             : }
    2952             : 
    2953             : static bool
    2954        2656 : _equalCreatePublicationStmt(const CreatePublicationStmt *a, const CreatePublicationStmt *b)
    2955             : {
    2956        2656 :     COMPARE_STRING_FIELD(pubname);
    2957        2656 :     COMPARE_NODE_FIELD(options);
    2958        2656 :     COMPARE_NODE_FIELD(pubobjects);
    2959        2656 :     COMPARE_SCALAR_FIELD(for_all_tables);
    2960             : 
    2961        2656 :     return true;
    2962             : }
    2963             : 
    2964             : static bool
    2965        4048 : _equalAlterPublicationStmt(const AlterPublicationStmt *a, const AlterPublicationStmt *b)
    2966             : {
    2967        4048 :     COMPARE_STRING_FIELD(pubname);
    2968        4048 :     COMPARE_NODE_FIELD(options);
    2969        4048 :     COMPARE_NODE_FIELD(pubobjects);
    2970        4048 :     COMPARE_SCALAR_FIELD(for_all_tables);
    2971        4048 :     COMPARE_SCALAR_FIELD(action);
    2972             : 
    2973        4048 :     return true;
    2974             : }
    2975             : 
    2976             : static bool
    2977        1472 : _equalCreateSubscriptionStmt(const CreateSubscriptionStmt *a, const CreateSubscriptionStmt *b)
    2978             : {
    2979        1472 :     COMPARE_STRING_FIELD(subname);
    2980        1472 :     COMPARE_STRING_FIELD(conninfo);
    2981        1472 :     COMPARE_NODE_FIELD(publication);
    2982        1472 :     COMPARE_NODE_FIELD(options);
    2983             : 
    2984        1472 :     return true;
    2985             : }
    2986             : 
    2987             : static bool
    2988        1724 : _equalAlterSubscriptionStmt(const AlterSubscriptionStmt *a, const AlterSubscriptionStmt *b)
    2989             : {
    2990        1724 :     COMPARE_SCALAR_FIELD(kind);
    2991        1724 :     COMPARE_STRING_FIELD(subname);
    2992        1724 :     COMPARE_STRING_FIELD(conninfo);
    2993        1724 :     COMPARE_NODE_FIELD(publication);
    2994        1724 :     COMPARE_NODE_FIELD(options);
    2995             : 
    2996        1724 :     return true;
    2997             : }
    2998             : 
    2999             : static bool
    3000         656 : _equalDropSubscriptionStmt(const DropSubscriptionStmt *a, const DropSubscriptionStmt *b)
    3001             : {
    3002         656 :     COMPARE_STRING_FIELD(subname);
    3003         656 :     COMPARE_SCALAR_FIELD(missing_ok);
    3004         656 :     COMPARE_SCALAR_FIELD(behavior);
    3005             : 
    3006         656 :     return true;
    3007             : }
    3008             : 
    3009             : static bool
    3010           0 : _equalPathKey(const PathKey *a, const PathKey *b)
    3011             : {
    3012           0 :     COMPARE_SCALAR_FIELD(pk_eclass);
    3013           0 :     COMPARE_SCALAR_FIELD(pk_opfamily);
    3014           0 :     COMPARE_SCALAR_FIELD(pk_strategy);
    3015           0 :     COMPARE_SCALAR_FIELD(pk_nulls_first);
    3016             : 
    3017           0 :     return true;
    3018             : }
    3019             : 
    3020             : static bool
    3021           0 : _equalRestrictInfo(const RestrictInfo *a, const RestrictInfo *b)
    3022             : {
    3023           0 :     COMPARE_NODE_FIELD(clause);
    3024           0 :     COMPARE_SCALAR_FIELD(is_pushed_down);
    3025           0 :     COMPARE_SCALAR_FIELD(has_clone);
    3026           0 :     COMPARE_SCALAR_FIELD(is_clone);
    3027           0 :     COMPARE_SCALAR_FIELD(security_level);
    3028           0 :     COMPARE_BITMAPSET_FIELD(required_relids);
    3029           0 :     COMPARE_BITMAPSET_FIELD(incompatible_relids);
    3030           0 :     COMPARE_BITMAPSET_FIELD(outer_relids);
    3031           0 :     COMPARE_SCALAR_FIELD(rinfo_serial);
    3032             : 
    3033           0 :     return true;
    3034             : }
    3035             : 
    3036             : static bool
    3037         966 : _equalPlaceHolderVar(const PlaceHolderVar *a, const PlaceHolderVar *b)
    3038             : {
    3039         966 :     COMPARE_BITMAPSET_FIELD(phnullingrels);
    3040         954 :     COMPARE_SCALAR_FIELD(phid);
    3041         750 :     COMPARE_SCALAR_FIELD(phlevelsup);
    3042             : 
    3043         750 :     return true;
    3044             : }
    3045             : 
    3046             : static bool
    3047           0 : _equalSpecialJoinInfo(const SpecialJoinInfo *a, const SpecialJoinInfo *b)
    3048             : {
    3049           0 :     COMPARE_BITMAPSET_FIELD(min_lefthand);
    3050           0 :     COMPARE_BITMAPSET_FIELD(min_righthand);
    3051           0 :     COMPARE_BITMAPSET_FIELD(syn_lefthand);
    3052           0 :     COMPARE_BITMAPSET_FIELD(syn_righthand);
    3053           0 :     COMPARE_SCALAR_FIELD(jointype);
    3054           0 :     COMPARE_SCALAR_FIELD(ojrelid);
    3055           0 :     COMPARE_BITMAPSET_FIELD(commute_above_l);
    3056           0 :     COMPARE_BITMAPSET_FIELD(commute_above_r);
    3057           0 :     COMPARE_BITMAPSET_FIELD(commute_below_l);
    3058           0 :     COMPARE_BITMAPSET_FIELD(commute_below_r);
    3059           0 :     COMPARE_SCALAR_FIELD(lhs_strict);
    3060           0 :     COMPARE_SCALAR_FIELD(semi_can_btree);
    3061           0 :     COMPARE_SCALAR_FIELD(semi_can_hash);
    3062           0 :     COMPARE_NODE_FIELD(semi_operators);
    3063           0 :     COMPARE_NODE_FIELD(semi_rhs_exprs);
    3064             : 
    3065           0 :     return true;
    3066             : }
    3067             : 
    3068             : static bool
    3069           0 : _equalAppendRelInfo(const AppendRelInfo *a, const AppendRelInfo *b)
    3070             : {
    3071           0 :     COMPARE_SCALAR_FIELD(parent_relid);
    3072           0 :     COMPARE_SCALAR_FIELD(child_relid);
    3073           0 :     COMPARE_SCALAR_FIELD(parent_reltype);
    3074           0 :     COMPARE_SCALAR_FIELD(child_reltype);
    3075           0 :     COMPARE_NODE_FIELD(translated_vars);
    3076           0 :     COMPARE_SCALAR_FIELD(num_child_cols);
    3077           0 :     COMPARE_POINTER_FIELD(parent_colnos, a->num_child_cols * sizeof(AttrNumber));
    3078           0 :     COMPARE_SCALAR_FIELD(parent_reloid);
    3079             : 
    3080           0 :     return true;
    3081             : }
    3082             : 
    3083             : static bool
    3084           0 : _equalPlaceHolderInfo(const PlaceHolderInfo *a, const PlaceHolderInfo *b)
    3085             : {
    3086           0 :     COMPARE_SCALAR_FIELD(phid);
    3087           0 :     COMPARE_NODE_FIELD(ph_var);
    3088           0 :     COMPARE_BITMAPSET_FIELD(ph_eval_at);
    3089           0 :     COMPARE_BITMAPSET_FIELD(ph_lateral);
    3090           0 :     COMPARE_BITMAPSET_FIELD(ph_needed);
    3091           0 :     COMPARE_SCALAR_FIELD(ph_width);
    3092             : 
    3093           0 :     return true;
    3094             : }
    3095             : 
    3096             : static bool
    3097      897352 : _equalInteger(const Integer *a, const Integer *b)
    3098             : {
    3099      897352 :     COMPARE_SCALAR_FIELD(ival);
    3100             : 
    3101      897352 :     return true;
    3102             : }
    3103             : 
    3104             : static bool
    3105       21912 : _equalFloat(const Float *a, const Float *b)
    3106             : {
    3107       21912 :     COMPARE_STRING_FIELD(fval);
    3108             : 
    3109       21912 :     return true;
    3110             : }
    3111             : 
    3112             : static bool
    3113      153972 : _equalBoolean(const Boolean *a, const Boolean *b)
    3114             : {
    3115      153972 :     COMPARE_SCALAR_FIELD(boolval);
    3116             : 
    3117      153972 :     return true;
    3118             : }
    3119             : 
    3120             : static bool
    3121    25952578 : _equalString(const String *a, const String *b)
    3122             : {
    3123    25952578 :     COMPARE_STRING_FIELD(sval);
    3124             : 
    3125    25951428 :     return true;
    3126             : }
    3127             : 
    3128             : static bool
    3129        8088 : _equalBitString(const BitString *a, const BitString *b)
    3130             : {
    3131        8088 :     COMPARE_STRING_FIELD(bsval);
    3132             : 
    3133        8088 :     return true;
    3134             : }

Generated by: LCOV version 1.14