LCOV - code coverage report
Current view: top level - src/backend/nodes - equalfuncs.funcs.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 1803 1872 96.3 %
Date: 2025-04-24 12:15:10 Functions: 263 272 96.7 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14