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

Generated by: LCOV version 1.14