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

Generated by: LCOV version 1.16