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

Generated by: LCOV version 1.14