LCOV - code coverage report
Current view: top level - src/backend/nodes - equalfuncs.switch.c Coverage Total Hit
Test: PostgreSQL 20devel Lines: 95.4 % 849 810
Test Date: 2026-11-21 17:16:00 Functions: - 0 0
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /*-------------------------------------------------------------------------
       2              :  *
       3              :  * equalfuncs.switch.c
       4              :  *    Generated node infrastructure code
       5              :  *
       6              :  * Portions Copyright (c) 1996-2026, 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      1793281 :         case T_Alias:
      19      1793281 :             retval = _equalAlias(a, b);
      20      1793281 :             break;
      21      1151609 :         case T_RangeVar:
      22      1151609 :             retval = _equalRangeVar(a, b);
      23      1151609 :             break;
      24         1132 :         case T_TableFunc:
      25         1132 :             retval = _equalTableFunc(a, b);
      26         1132 :             break;
      27         5328 :         case T_IntoClause:
      28         5328 :             retval = _equalIntoClause(a, b);
      29         5328 :             break;
      30     13339515 :         case T_Var:
      31     13339515 :             retval = _equalVar(a, b);
      32     13339515 :             break;
      33      1748680 :         case T_Const:
      34      1748680 :             retval = _equalConst(a, b);
      35      1748680 :             break;
      36       114145 :         case T_Param:
      37       114145 :             retval = _equalParam(a, b);
      38       114145 :             break;
      39        84402 :         case T_Aggref:
      40        84402 :             retval = _equalAggref(a, b);
      41        84402 :             break;
      42         1116 :         case T_GroupingFunc:
      43         1116 :             retval = _equalGroupingFunc(a, b);
      44         1116 :             break;
      45         6974 :         case T_WindowFunc:
      46         6974 :             retval = _equalWindowFunc(a, b);
      47         6974 :             break;
      48          195 :         case T_WindowFuncRunCondition:
      49          195 :             retval = _equalWindowFuncRunCondition(a, b);
      50          195 :             break;
      51          618 :         case T_MergeSupportFunc:
      52          618 :             retval = _equalMergeSupportFunc(a, b);
      53          618 :             break;
      54        21726 :         case T_SubscriptingRef:
      55        21726 :             retval = _equalSubscriptingRef(a, b);
      56        21726 :             break;
      57       551698 :         case T_FuncExpr:
      58       551698 :             retval = _equalFuncExpr(a, b);
      59       551698 :             break;
      60       102424 :         case T_NamedArgExpr:
      61       102424 :             retval = _equalNamedArgExpr(a, b);
      62       102424 :             break;
      63      1048657 :         case T_OpExpr:
      64      1048657 :             retval = _equalOpExpr(a, b);
      65      1048657 :             break;
      66         1362 :         case T_DistinctExpr:
      67         1362 :             retval = _equalDistinctExpr(a, b);
      68         1362 :             break;
      69          323 :         case T_NullIfExpr:
      70          323 :             retval = _equalNullIfExpr(a, b);
      71          323 :             break;
      72        43439 :         case T_ScalarArrayOpExpr:
      73        43439 :             retval = _equalScalarArrayOpExpr(a, b);
      74        43439 :             break;
      75       488820 :         case T_BoolExpr:
      76       488820 :             retval = _equalBoolExpr(a, b);
      77       488820 :             break;
      78       143830 :         case T_SubLink:
      79       143830 :             retval = _equalSubLink(a, b);
      80       143830 :             break;
      81         5406 :         case T_SubPlan:
      82         5406 :             retval = _equalSubPlan(a, b);
      83         5406 :             break;
      84            0 :         case T_AlternativeSubPlan:
      85            0 :             retval = _equalAlternativeSubPlan(a, b);
      86            0 :             break;
      87        32757 :         case T_FieldSelect:
      88        32757 :             retval = _equalFieldSelect(a, b);
      89        32757 :             break;
      90          618 :         case T_FieldStore:
      91          618 :             retval = _equalFieldStore(a, b);
      92          618 :             break;
      93       216382 :         case T_RelabelType:
      94       216382 :             retval = _equalRelabelType(a, b);
      95       216382 :             break;
      96        40269 :         case T_CoerceViaIO:
      97        40269 :             retval = _equalCoerceViaIO(a, b);
      98        40269 :             break;
      99         6828 :         case T_ArrayCoerceExpr:
     100         6828 :             retval = _equalArrayCoerceExpr(a, b);
     101         6828 :             break;
     102           94 :         case T_ConvertRowtypeExpr:
     103           94 :             retval = _equalConvertRowtypeExpr(a, b);
     104           94 :             break;
     105        13099 :         case T_CollateExpr:
     106        13099 :             retval = _equalCollateExpr(a, b);
     107        13099 :             break;
     108       129549 :         case T_CaseExpr:
     109       129549 :             retval = _equalCaseExpr(a, b);
     110       129549 :             break;
     111       248139 :         case T_CaseWhen:
     112       248139 :             retval = _equalCaseWhen(a, b);
     113       248139 :             break;
     114        35579 :         case T_CaseTestExpr:
     115        35579 :             retval = _equalCaseTestExpr(a, b);
     116        35579 :             break;
     117        33687 :         case T_ArrayExpr:
     118        33687 :             retval = _equalArrayExpr(a, b);
     119        33687 :             break;
     120        17938 :         case T_RowExpr:
     121        17938 :             retval = _equalRowExpr(a, b);
     122        17938 :             break;
     123          506 :         case T_RowCompareExpr:
     124          506 :             retval = _equalRowCompareExpr(a, b);
     125          506 :             break;
     126        12874 :         case T_CoalesceExpr:
     127        12874 :             retval = _equalCoalesceExpr(a, b);
     128        12874 :             break;
     129          781 :         case T_MinMaxExpr:
     130          781 :             retval = _equalMinMaxExpr(a, b);
     131          781 :             break;
     132        10041 :         case T_SQLValueFunction:
     133        10041 :             retval = _equalSQLValueFunction(a, b);
     134        10041 :             break;
     135         1908 :         case T_XmlExpr:
     136         1908 :             retval = _equalXmlExpr(a, b);
     137         1908 :             break;
     138        26964 :         case T_JsonFormat:
     139        26964 :             retval = _equalJsonFormat(a, b);
     140        26964 :             break;
     141         9466 :         case T_JsonReturning:
     142         9466 :             retval = _equalJsonReturning(a, b);
     143         9466 :             break;
     144         8756 :         case T_JsonValueExpr:
     145         8756 :             retval = _equalJsonValueExpr(a, b);
     146         8756 :             break;
     147         2212 :         case T_JsonConstructorExpr:
     148         2212 :             retval = _equalJsonConstructorExpr(a, b);
     149         2212 :             break;
     150         1144 :         case T_JsonIsPredicate:
     151         1144 :             retval = _equalJsonIsPredicate(a, b);
     152         1144 :             break;
     153        10166 :         case T_JsonBehavior:
     154        10166 :             retval = _equalJsonBehavior(a, b);
     155        10166 :             break;
     156         4688 :         case T_JsonExpr:
     157         4688 :             retval = _equalJsonExpr(a, b);
     158         4688 :             break;
     159         1404 :         case T_JsonTablePath:
     160         1404 :             retval = _equalJsonTablePath(a, b);
     161         1404 :             break;
     162         1404 :         case T_JsonTablePathScan:
     163         1404 :             retval = _equalJsonTablePathScan(a, b);
     164         1404 :             break;
     165          206 :         case T_JsonTableSiblingJoin:
     166          206 :             retval = _equalJsonTableSiblingJoin(a, b);
     167          206 :             break;
     168        54177 :         case T_NullTest:
     169        54177 :             retval = _equalNullTest(a, b);
     170        54177 :             break;
     171         3362 :         case T_BooleanTest:
     172         3362 :             retval = _equalBooleanTest(a, b);
     173         3362 :             break;
     174         4210 :         case T_MergeAction:
     175         4210 :             retval = _equalMergeAction(a, b);
     176         4210 :             break;
     177        46606 :         case T_CoerceToDomain:
     178        46606 :             retval = _equalCoerceToDomain(a, b);
     179        46606 :             break;
     180            0 :         case T_CoerceToDomainValue:
     181            0 :             retval = _equalCoerceToDomainValue(a, b);
     182            0 :             break;
     183         2004 :         case T_SetToDefault:
     184         2004 :             retval = _equalSetToDefault(a, b);
     185         2004 :             break;
     186          688 :         case T_CurrentOfExpr:
     187          688 :             retval = _equalCurrentOfExpr(a, b);
     188          688 :             break;
     189          572 :         case T_NextValueExpr:
     190          572 :             retval = _equalNextValueExpr(a, b);
     191          572 :             break;
     192         3430 :         case T_InferenceElem:
     193         3430 :             retval = _equalInferenceElem(a, b);
     194         3430 :             break;
     195          552 :         case T_ReturningExpr:
     196          552 :             retval = _equalReturningExpr(a, b);
     197          552 :             break;
     198      2143387 :         case T_TargetEntry:
     199      2143387 :             retval = _equalTargetEntry(a, b);
     200      2143387 :             break;
     201       714074 :         case T_RangeTblRef:
     202       714074 :             retval = _equalRangeTblRef(a, b);
     203       714074 :             break;
     204       255260 :         case T_JoinExpr:
     205       255260 :             retval = _equalJoinExpr(a, b);
     206       255260 :             break;
     207       766058 :         case T_FromExpr:
     208       766058 :             retval = _equalFromExpr(a, b);
     209       766058 :             break;
     210         3490 :         case T_OnConflictExpr:
     211         3490 :             retval = _equalOnConflictExpr(a, b);
     212         3490 :             break;
     213      1277535 :         case T_Query:
     214      1277535 :             retval = _equalQuery(a, b);
     215      1277535 :             break;
     216       999484 :         case T_TypeName:
     217       999484 :             retval = _equalTypeName(a, b);
     218       999484 :             break;
     219      2733006 :         case T_ColumnRef:
     220      2733006 :             retval = _equalColumnRef(a, b);
     221      2733006 :             break;
     222        66788 :         case T_ParamRef:
     223        66788 :             retval = _equalParamRef(a, b);
     224        66788 :             break;
     225       875008 :         case T_A_Expr:
     226       875008 :             retval = _equalA_Expr(a, b);
     227       875008 :             break;
     228      1919448 :         case T_A_Const:
     229      1919448 :             retval = _equalA_Const(a, b);
     230      1919448 :             break;
     231       471686 :         case T_TypeCast:
     232       471686 :             retval = _equalTypeCast(a, b);
     233       471686 :             break;
     234        15846 :         case T_CollateClause:
     235        15846 :             retval = _equalCollateClause(a, b);
     236        15846 :             break;
     237        58240 :         case T_RoleSpec:
     238        58240 :             retval = _equalRoleSpec(a, b);
     239        58240 :             break;
     240       549124 :         case T_FuncCall:
     241       549124 :             retval = _equalFuncCall(a, b);
     242       549124 :             break;
     243        94952 :         case T_A_Star:
     244        94952 :             retval = _equalA_Star(a, b);
     245        94952 :             break;
     246        20852 :         case T_A_Indices:
     247        20852 :             retval = _equalA_Indices(a, b);
     248        20852 :             break;
     249        52844 :         case T_A_Indirection:
     250        52844 :             retval = _equalA_Indirection(a, b);
     251        52844 :             break;
     252        10764 :         case T_A_ArrayExpr:
     253        10764 :             retval = _equalA_ArrayExpr(a, b);
     254        10764 :             break;
     255      1710316 :         case T_ResTarget:
     256      1710316 :             retval = _equalResTarget(a, b);
     257      1710316 :             break;
     258          530 :         case T_MultiAssignRef:
     259          530 :             retval = _equalMultiAssignRef(a, b);
     260          530 :             break;
     261       148964 :         case T_SortBy:
     262       148964 :             retval = _equalSortBy(a, b);
     263       148964 :             break;
     264         6756 :         case T_WindowDef:
     265         6756 :             retval = _equalWindowDef(a, b);
     266         6756 :             break;
     267        33654 :         case T_RangeSubselect:
     268        33654 :             retval = _equalRangeSubselect(a, b);
     269        33654 :             break;
     270        68556 :         case T_RangeFunction:
     271        68556 :             retval = _equalRangeFunction(a, b);
     272        68556 :             break;
     273          336 :         case T_RangeTableFunc:
     274          336 :             retval = _equalRangeTableFunc(a, b);
     275          336 :             break;
     276         1164 :         case T_RangeTableFuncCol:
     277         1164 :             retval = _equalRangeTableFuncCol(a, b);
     278         1164 :             break;
     279          404 :         case T_RangeTableSample:
     280          404 :             retval = _equalRangeTableSample(a, b);
     281          404 :             break;
     282       201124 :         case T_ColumnDef:
     283       201124 :             retval = _equalColumnDef(a, b);
     284       201124 :             break;
     285         2168 :         case T_TableLikeClause:
     286         2168 :             retval = _equalTableLikeClause(a, b);
     287         2168 :             break;
     288        27757 :         case T_IndexElem:
     289        27757 :             retval = _equalIndexElem(a, b);
     290        27757 :             break;
     291       431938 :         case T_DefElem:
     292       431938 :             retval = _equalDefElem(a, b);
     293       431938 :             break;
     294         7976 :         case T_LockingClause:
     295         7976 :             retval = _equalLockingClause(a, b);
     296         7976 :             break;
     297          328 :         case T_XmlSerialize:
     298          328 :             retval = _equalXmlSerialize(a, b);
     299          328 :             break;
     300        15602 :         case T_PartitionElem:
     301        15602 :             retval = _equalPartitionElem(a, b);
     302        15602 :             break;
     303        14314 :         case T_PartitionSpec:
     304        14314 :             retval = _equalPartitionSpec(a, b);
     305        14314 :             break;
     306        29812 :         case T_PartitionBoundSpec:
     307        29812 :             retval = _equalPartitionBoundSpec(a, b);
     308        29812 :             break;
     309            0 :         case T_PartitionRangeDatum:
     310            0 :             retval = _equalPartitionRangeDatum(a, b);
     311            0 :             break;
     312         9076 :         case T_PartitionCmd:
     313         9076 :             retval = _equalPartitionCmd(a, b);
     314         9076 :             break;
     315       951649 :         case T_RangeTblEntry:
     316       951649 :             retval = _equalRangeTblEntry(a, b);
     317       951649 :             break;
     318       645990 :         case T_RTEPermissionInfo:
     319       645990 :             retval = _equalRTEPermissionInfo(a, b);
     320       645990 :             break;
     321        63486 :         case T_RangeTblFunction:
     322        63486 :             retval = _equalRangeTblFunction(a, b);
     323        63486 :             break;
     324          314 :         case T_TableSampleClause:
     325          314 :             retval = _equalTableSampleClause(a, b);
     326          314 :             break;
     327         7705 :         case T_WithCheckOption:
     328         7705 :             retval = _equalWithCheckOption(a, b);
     329         7705 :             break;
     330       203726 :         case T_SortGroupClause:
     331       203726 :             retval = _equalSortGroupClause(a, b);
     332       203726 :             break;
     333         7188 :         case T_GroupingSet:
     334         7188 :             retval = _equalGroupingSet(a, b);
     335         7188 :             break;
     336         4316 :         case T_WindowClause:
     337         4316 :             retval = _equalWindowClause(a, b);
     338         4316 :             break;
     339        10306 :         case T_RowMarkClause:
     340        10306 :             retval = _equalRowMarkClause(a, b);
     341        10306 :             break;
     342         4950 :         case T_WithClause:
     343         4950 :             retval = _equalWithClause(a, b);
     344         4950 :             break;
     345         3278 :         case T_InferClause:
     346         3278 :             retval = _equalInferClause(a, b);
     347         3278 :             break;
     348         3610 :         case T_OnConflictClause:
     349         3610 :             retval = _equalOnConflictClause(a, b);
     350         3610 :             break;
     351          312 :         case T_CTESearchClause:
     352          312 :             retval = _equalCTESearchClause(a, b);
     353          312 :             break;
     354          328 :         case T_CTECycleClause:
     355          328 :             retval = _equalCTECycleClause(a, b);
     356          328 :             break;
     357        12286 :         case T_CommonTableExpr:
     358        12286 :             retval = _equalCommonTableExpr(a, b);
     359        12286 :             break;
     360         4352 :         case T_MergeWhenClause:
     361         4352 :             retval = _equalMergeWhenClause(a, b);
     362         4352 :             break;
     363          256 :         case T_ReturningOption:
     364          256 :             retval = _equalReturningOption(a, b);
     365          256 :             break;
     366         5400 :         case T_ReturningClause:
     367         5400 :             retval = _equalReturningClause(a, b);
     368         5400 :             break;
     369         1712 :         case T_TriggerTransition:
     370         1712 :             retval = _equalTriggerTransition(a, b);
     371         1712 :             break;
     372         2570 :         case T_JsonOutput:
     373         2570 :             retval = _equalJsonOutput(a, b);
     374         2570 :             break;
     375         1038 :         case T_JsonArgument:
     376         1038 :             retval = _equalJsonArgument(a, b);
     377         1038 :             break;
     378         3310 :         case T_JsonFuncExpr:
     379         3310 :             retval = _equalJsonFuncExpr(a, b);
     380         3310 :             break;
     381         5166 :         case T_JsonTablePathSpec:
     382         5166 :             retval = _equalJsonTablePathSpec(a, b);
     383         5166 :             break;
     384         1192 :         case T_JsonTablePlanSpec:
     385         1192 :             retval = _equalJsonTablePlanSpec(a, b);
     386         1192 :             break;
     387         1308 :         case T_JsonTable:
     388         1308 :             retval = _equalJsonTable(a, b);
     389         1308 :             break;
     390         4592 :         case T_JsonTableColumn:
     391         4592 :             retval = _equalJsonTableColumn(a, b);
     392         4592 :             break;
     393         1202 :         case T_JsonKeyValue:
     394         1202 :             retval = _equalJsonKeyValue(a, b);
     395         1202 :             break;
     396          222 :         case T_JsonParseExpr:
     397          222 :             retval = _equalJsonParseExpr(a, b);
     398          222 :             break;
     399          142 :         case T_JsonScalarExpr:
     400          142 :             retval = _equalJsonScalarExpr(a, b);
     401          142 :             break;
     402          142 :         case T_JsonSerializeExpr:
     403          142 :             retval = _equalJsonSerializeExpr(a, b);
     404          142 :             break;
     405          654 :         case T_JsonObjectConstructor:
     406          654 :             retval = _equalJsonObjectConstructor(a, b);
     407          654 :             break;
     408          294 :         case T_JsonArrayConstructor:
     409          294 :             retval = _equalJsonArrayConstructor(a, b);
     410          294 :             break;
     411          238 :         case T_JsonArrayQueryConstructor:
     412          238 :             retval = _equalJsonArrayQueryConstructor(a, b);
     413          238 :             break;
     414          626 :         case T_JsonAggConstructor:
     415          626 :             retval = _equalJsonAggConstructor(a, b);
     416          626 :             break;
     417          324 :         case T_JsonObjectAgg:
     418          324 :             retval = _equalJsonObjectAgg(a, b);
     419          324 :             break;
     420          302 :         case T_JsonArrayAgg:
     421          302 :             retval = _equalJsonArrayAgg(a, b);
     422          302 :             break;
     423       967736 :         case T_RawStmt:
     424       967736 :             retval = _equalRawStmt(a, b);
     425       967736 :             break;
     426        91874 :         case T_InsertStmt:
     427        91874 :             retval = _equalInsertStmt(a, b);
     428        91874 :             break;
     429         5884 :         case T_DeleteStmt:
     430         5884 :             retval = _equalDeleteStmt(a, b);
     431         5884 :             break;
     432        17588 :         case T_UpdateStmt:
     433        17588 :             retval = _equalUpdateStmt(a, b);
     434        17588 :             break;
     435         2798 :         case T_MergeStmt:
     436         2798 :             retval = _equalMergeStmt(a, b);
     437         2798 :             break;
     438       709242 :         case T_SelectStmt:
     439       709242 :             retval = _equalSelectStmt(a, b);
     440       709242 :             break;
     441        27368 :         case T_SetOperationStmt:
     442        27368 :             retval = _equalSetOperationStmt(a, b);
     443        27368 :             break;
     444        11904 :         case T_ReturnStmt:
     445        11904 :             retval = _equalReturnStmt(a, b);
     446        11904 :             break;
     447            0 :         case T_PLAssignStmt:
     448            0 :             retval = _equalPLAssignStmt(a, b);
     449            0 :             break;
     450         3020 :         case T_CreateSchemaStmt:
     451         3020 :             retval = _equalCreateSchemaStmt(a, b);
     452         3020 :             break;
     453        87342 :         case T_AlterTableStmt:
     454        87342 :             retval = _equalAlterTableStmt(a, b);
     455        87342 :             break;
     456        90250 :         case T_AlterTableCmd:
     457        90250 :             retval = _equalAlterTableCmd(a, b);
     458        90250 :             break;
     459         1392 :         case T_ATAlterConstraint:
     460         1392 :             retval = _equalATAlterConstraint(a, b);
     461         1392 :             break;
     462         1288 :         case T_ReplicaIdentityStmt:
     463         1288 :             retval = _equalReplicaIdentityStmt(a, b);
     464         1288 :             break;
     465           16 :         case T_AlterCollationStmt:
     466           16 :             retval = _equalAlterCollationStmt(a, b);
     467           16 :             break;
     468          792 :         case T_AlterDomainStmt:
     469          792 :             retval = _equalAlterDomainStmt(a, b);
     470          792 :             break;
     471        33756 :         case T_GrantStmt:
     472        33756 :             retval = _equalGrantStmt(a, b);
     473        33756 :             break;
     474        35480 :         case T_ObjectWithArgs:
     475        35480 :             retval = _equalObjectWithArgs(a, b);
     476        35480 :             break;
     477        29960 :         case T_AccessPriv:
     478        29960 :             retval = _equalAccessPriv(a, b);
     479        29960 :             break;
     480         1728 :         case T_GrantRoleStmt:
     481         1728 :             retval = _equalGrantRoleStmt(a, b);
     482         1728 :             break;
     483          540 :         case T_AlterDefaultPrivilegesStmt:
     484          540 :             retval = _equalAlterDefaultPrivilegesStmt(a, b);
     485          540 :             break;
     486        27190 :         case T_CopyStmt:
     487        27190 :             retval = _equalCopyStmt(a, b);
     488        27190 :             break;
     489        79994 :         case T_VariableSetStmt:
     490        79994 :             retval = _equalVariableSetStmt(a, b);
     491        79994 :             break;
     492         2484 :         case T_VariableShowStmt:
     493         2484 :             retval = _equalVariableShowStmt(a, b);
     494         2484 :             break;
     495       105716 :         case T_CreateStmt:
     496       105716 :             retval = _equalCreateStmt(a, b);
     497       105716 :             break;
     498        94326 :         case T_Constraint:
     499        94326 :             retval = _equalConstraint(a, b);
     500        94326 :             break;
     501          332 :         case T_CreateTableSpaceStmt:
     502          332 :             retval = _equalCreateTableSpaceStmt(a, b);
     503          332 :             break;
     504          196 :         case T_DropTableSpaceStmt:
     505          196 :             retval = _equalDropTableSpaceStmt(a, b);
     506          196 :             break;
     507           76 :         case T_AlterTableSpaceOptionsStmt:
     508           76 :             retval = _equalAlterTableSpaceOptionsStmt(a, b);
     509           76 :             break;
     510           64 :         case T_AlterTableMoveAllStmt:
     511           64 :             retval = _equalAlterTableMoveAllStmt(a, b);
     512           64 :             break;
     513         1516 :         case T_CreateExtensionStmt:
     514         1516 :             retval = _equalCreateExtensionStmt(a, b);
     515         1516 :             break;
     516           78 :         case T_AlterExtensionStmt:
     517           78 :             retval = _equalAlterExtensionStmt(a, b);
     518           78 :             break;
     519          588 :         case T_AlterExtensionContentsStmt:
     520          588 :             retval = _equalAlterExtensionContentsStmt(a, b);
     521          588 :             break;
     522          640 :         case T_CreateFdwStmt:
     523          640 :             retval = _equalCreateFdwStmt(a, b);
     524          640 :             break;
     525          412 :         case T_AlterFdwStmt:
     526          412 :             retval = _equalAlterFdwStmt(a, b);
     527          412 :             break;
     528          798 :         case T_CreateForeignServerStmt:
     529          798 :             retval = _equalCreateForeignServerStmt(a, b);
     530          798 :             break;
     531          524 :         case T_AlterForeignServerStmt:
     532          524 :             retval = _equalAlterForeignServerStmt(a, b);
     533          524 :             break;
     534         1232 :         case T_CreateForeignTableStmt:
     535         1232 :             retval = _equalCreateForeignTableStmt(a, b);
     536         1232 :             break;
     537          668 :         case T_CreateUserMappingStmt:
     538          668 :             retval = _equalCreateUserMappingStmt(a, b);
     539          668 :             break;
     540          300 :         case T_AlterUserMappingStmt:
     541          300 :             retval = _equalAlterUserMappingStmt(a, b);
     542          300 :             break;
     543          316 :         case T_DropUserMappingStmt:
     544          316 :             retval = _equalDropUserMappingStmt(a, b);
     545          316 :             break;
     546          112 :         case T_ImportForeignSchemaStmt:
     547          112 :             retval = _equalImportForeignSchemaStmt(a, b);
     548          112 :             break;
     549         2188 :         case T_CreatePolicyStmt:
     550         2188 :             retval = _equalCreatePolicyStmt(a, b);
     551         2188 :             break;
     552          224 :         case T_AlterPolicyStmt:
     553          224 :             retval = _equalAlterPolicyStmt(a, b);
     554          224 :             break;
     555          152 :         case T_CreateAmStmt:
     556          152 :             retval = _equalCreateAmStmt(a, b);
     557          152 :             break;
     558         8300 :         case T_CreateTrigStmt:
     559         8300 :             retval = _equalCreateTrigStmt(a, b);
     560         8300 :             break;
     561          516 :         case T_CreateEventTrigStmt:
     562          516 :             retval = _equalCreateEventTrigStmt(a, b);
     563          516 :             break;
     564          128 :         case T_AlterEventTrigStmt:
     565          128 :             retval = _equalAlterEventTrigStmt(a, b);
     566          128 :             break;
     567          336 :         case T_CreatePLangStmt:
     568          336 :             retval = _equalCreatePLangStmt(a, b);
     569          336 :             break;
     570         5264 :         case T_CreateRoleStmt:
     571         5264 :             retval = _equalCreateRoleStmt(a, b);
     572         5264 :             break;
     573         1224 :         case T_AlterRoleStmt:
     574         1224 :             retval = _equalAlterRoleStmt(a, b);
     575         1224 :             break;
     576          208 :         case T_AlterRoleSetStmt:
     577          208 :             retval = _equalAlterRoleSetStmt(a, b);
     578          208 :             break;
     579         4892 :         case T_DropRoleStmt:
     580         4892 :             retval = _equalDropRoleStmt(a, b);
     581         4892 :             break;
     582         1800 :         case T_CreateSeqStmt:
     583         1800 :             retval = _equalCreateSeqStmt(a, b);
     584         1800 :             break;
     585          532 :         case T_AlterSeqStmt:
     586          532 :             retval = _equalAlterSeqStmt(a, b);
     587          532 :             break;
     588        24164 :         case T_DefineStmt:
     589        24164 :             retval = _equalDefineStmt(a, b);
     590        24164 :             break;
     591         4514 :         case T_CreateDomainStmt:
     592         4514 :             retval = _equalCreateDomainStmt(a, b);
     593         4514 :             break;
     594         1304 :         case T_CreateOpClassStmt:
     595         1304 :             retval = _equalCreateOpClassStmt(a, b);
     596         1304 :             break;
     597        15440 :         case T_CreateOpClassItem:
     598        15440 :             retval = _equalCreateOpClassItem(a, b);
     599        15440 :             break;
     600          396 :         case T_CreateOpFamilyStmt:
     601          396 :             retval = _equalCreateOpFamilyStmt(a, b);
     602          396 :             break;
     603         1152 :         case T_AlterOpFamilyStmt:
     604         1152 :             retval = _equalAlterOpFamilyStmt(a, b);
     605         1152 :             break;
     606        76302 :         case T_DropStmt:
     607        76302 :             retval = _equalDropStmt(a, b);
     608        76302 :             break;
     609         4776 :         case T_TruncateStmt:
     610         4776 :             retval = _equalTruncateStmt(a, b);
     611         4776 :             break;
     612        18434 :         case T_CommentStmt:
     613        18434 :             retval = _equalCommentStmt(a, b);
     614        18434 :             break;
     615          268 :         case T_SecLabelStmt:
     616          268 :             retval = _equalSecLabelStmt(a, b);
     617          268 :             break;
     618         9362 :         case T_DeclareCursorStmt:
     619         9362 :             retval = _equalDeclareCursorStmt(a, b);
     620         9362 :             break;
     621         5548 :         case T_ClosePortalStmt:
     622         5548 :             retval = _equalClosePortalStmt(a, b);
     623         5548 :             break;
     624        16604 :         case T_FetchStmt:
     625        16604 :             retval = _equalFetchStmt(a, b);
     626        16604 :             break;
     627        17712 :         case T_IndexStmt:
     628        17712 :             retval = _equalIndexStmt(a, b);
     629        17712 :             break;
     630         2712 :         case T_CreateStatsStmt:
     631         2712 :             retval = _equalCreateStatsStmt(a, b);
     632         2712 :             break;
     633         6160 :         case T_StatsElem:
     634         6160 :             retval = _equalStatsElem(a, b);
     635         6160 :             break;
     636           68 :         case T_AlterStatsStmt:
     637           68 :             retval = _equalAlterStatsStmt(a, b);
     638           68 :             break;
     639        57190 :         case T_CreateFunctionStmt:
     640        57190 :             retval = _equalCreateFunctionStmt(a, b);
     641        57190 :             break;
     642       145912 :         case T_FunctionParameter:
     643       145912 :             retval = _equalFunctionParameter(a, b);
     644       145912 :             break;
     645          884 :         case T_AlterFunctionStmt:
     646          884 :             retval = _equalAlterFunctionStmt(a, b);
     647          884 :             break;
     648         3592 :         case T_DoStmt:
     649         3592 :             retval = _equalDoStmt(a, b);
     650         3592 :             break;
     651         1140 :         case T_CallStmt:
     652         1140 :             retval = _equalCallStmt(a, b);
     653         1140 :             break;
     654         3824 :         case T_RenameStmt:
     655         3824 :             retval = _equalRenameStmt(a, b);
     656         3824 :             break;
     657           92 :         case T_AlterObjectDependsStmt:
     658           92 :             retval = _equalAlterObjectDependsStmt(a, b);
     659           92 :             break;
     660         1084 :         case T_AlterObjectSchemaStmt:
     661         1084 :             retval = _equalAlterObjectSchemaStmt(a, b);
     662         1084 :             break;
     663         4212 :         case T_AlterOwnerStmt:
     664         4212 :             retval = _equalAlterOwnerStmt(a, b);
     665         4212 :             break;
     666         1344 :         case T_AlterOperatorStmt:
     667         1344 :             retval = _equalAlterOperatorStmt(a, b);
     668         1344 :             break;
     669          152 :         case T_AlterTypeStmt:
     670          152 :             retval = _equalAlterTypeStmt(a, b);
     671          152 :             break;
     672         2956 :         case T_RuleStmt:
     673         2956 :             retval = _equalRuleStmt(a, b);
     674         2956 :             break;
     675          367 :         case T_NotifyStmt:
     676          367 :             retval = _equalNotifyStmt(a, b);
     677          367 :             break;
     678          208 :         case T_ListenStmt:
     679          208 :             retval = _equalListenStmt(a, b);
     680          208 :             break;
     681          248 :         case T_UnlistenStmt:
     682          248 :             retval = _equalUnlistenStmt(a, b);
     683          248 :             break;
     684       110456 :         case T_TransactionStmt:
     685       110456 :             retval = _equalTransactionStmt(a, b);
     686       110456 :             break;
     687         7016 :         case T_CompositeTypeStmt:
     688         7016 :             retval = _equalCompositeTypeStmt(a, b);
     689         7016 :             break;
     690          826 :         case T_CreateEnumStmt:
     691          826 :             retval = _equalCreateEnumStmt(a, b);
     692          826 :             break;
     693          724 :         case T_CreateRangeStmt:
     694          724 :             retval = _equalCreateRangeStmt(a, b);
     695          724 :             break;
     696          984 :         case T_AlterEnumStmt:
     697          984 :             retval = _equalAlterEnumStmt(a, b);
     698          984 :             break;
     699        44846 :         case T_ViewStmt:
     700        44846 :             retval = _equalViewStmt(a, b);
     701        44846 :             break;
     702          200 :         case T_LoadStmt:
     703          200 :             retval = _equalLoadStmt(a, b);
     704          200 :             break;
     705         1920 :         case T_CreatedbStmt:
     706         1920 :             retval = _equalCreatedbStmt(a, b);
     707         1920 :             break;
     708          232 :         case T_AlterDatabaseStmt:
     709          232 :             retval = _equalAlterDatabaseStmt(a, b);
     710          232 :             break;
     711           16 :         case T_AlterDatabaseRefreshCollStmt:
     712           16 :             retval = _equalAlterDatabaseRefreshCollStmt(a, b);
     713           16 :             break;
     714         2788 :         case T_AlterDatabaseSetStmt:
     715         2788 :             retval = _equalAlterDatabaseSetStmt(a, b);
     716         2788 :             break;
     717          360 :         case T_DropdbStmt:
     718          360 :             retval = _equalDropdbStmt(a, b);
     719          360 :             break;
     720          524 :         case T_AlterSystemStmt:
     721          524 :             retval = _equalAlterSystemStmt(a, b);
     722          524 :             break;
     723        35812 :         case T_VacuumStmt:
     724        35812 :             retval = _equalVacuumStmt(a, b);
     725        35812 :             break;
     726        36594 :         case T_VacuumRelation:
     727        36594 :             retval = _equalVacuumRelation(a, b);
     728        36594 :             break;
     729         1202 :         case T_RepackStmt:
     730         1202 :             retval = _equalRepackStmt(a, b);
     731         1202 :             break;
     732        59012 :         case T_ExplainStmt:
     733        59012 :             retval = _equalExplainStmt(a, b);
     734        59012 :             break;
     735         5162 :         case T_CreateTableAsStmt:
     736         5162 :             retval = _equalCreateTableAsStmt(a, b);
     737         5162 :             break;
     738          760 :         case T_RefreshMatViewStmt:
     739          760 :             retval = _equalRefreshMatViewStmt(a, b);
     740          760 :             break;
     741          650 :         case T_CheckPointStmt:
     742          650 :             retval = _equalCheckPointStmt(a, b);
     743          650 :             break;
     744           96 :         case T_DiscardStmt:
     745           96 :             retval = _equalDiscardStmt(a, b);
     746           96 :             break;
     747         2490 :         case T_LockStmt:
     748         2490 :             retval = _equalLockStmt(a, b);
     749         2490 :             break;
     750          282 :         case T_ConstraintsSetStmt:
     751          282 :             retval = _equalConstraintsSetStmt(a, b);
     752          282 :             break;
     753         2948 :         case T_ReindexStmt:
     754         2948 :             retval = _equalReindexStmt(a, b);
     755         2948 :             break;
     756          168 :         case T_CreateConversionStmt:
     757          168 :             retval = _equalCreateConversionStmt(a, b);
     758          168 :             break;
     759          872 :         case T_CreateCastStmt:
     760          872 :             retval = _equalCreateCastStmt(a, b);
     761          872 :             break;
     762          104 :         case T_CreateTransformStmt:
     763          104 :             retval = _equalCreateTransformStmt(a, b);
     764          104 :             break;
     765         4936 :         case T_PrepareStmt:
     766         4936 :             retval = _equalPrepareStmt(a, b);
     767         4936 :             break;
     768        36000 :         case T_ExecuteStmt:
     769        36000 :             retval = _equalExecuteStmt(a, b);
     770        36000 :             break;
     771         8600 :         case T_DeallocateStmt:
     772         8600 :             retval = _equalDeallocateStmt(a, b);
     773         8600 :             break;
     774          436 :         case T_DropOwnedStmt:
     775          436 :             retval = _equalDropOwnedStmt(a, b);
     776          436 :             break;
     777          220 :         case T_ReassignOwnedStmt:
     778          220 :             retval = _equalReassignOwnedStmt(a, b);
     779          220 :             break;
     780           92 :         case T_AlterTSDictionaryStmt:
     781           92 :             retval = _equalAlterTSDictionaryStmt(a, b);
     782           92 :             break;
     783        22488 :         case T_AlterTSConfigurationStmt:
     784        22488 :             retval = _equalAlterTSConfigurationStmt(a, b);
     785        22488 :             break;
     786         4220 :         case T_PublicationTable:
     787         4220 :             retval = _equalPublicationTable(a, b);
     788         4220 :             break;
     789         5280 :         case T_PublicationObjSpec:
     790         5280 :             retval = _equalPublicationObjSpec(a, b);
     791         5280 :             break;
     792            0 :         case T_PublicationAllObjSpec:
     793            0 :             retval = _equalPublicationAllObjSpec(a, b);
     794            0 :             break;
     795         2644 :         case T_CreatePublicationStmt:
     796         2644 :             retval = _equalCreatePublicationStmt(a, b);
     797         2644 :             break;
     798         3144 :         case T_AlterPublicationStmt:
     799         3144 :             retval = _equalAlterPublicationStmt(a, b);
     800         3144 :             break;
     801         1452 :         case T_CreateSubscriptionStmt:
     802         1452 :             retval = _equalCreateSubscriptionStmt(a, b);
     803         1452 :             break;
     804         1898 :         case T_AlterSubscriptionStmt:
     805         1898 :             retval = _equalAlterSubscriptionStmt(a, b);
     806         1898 :             break;
     807          792 :         case T_DropSubscriptionStmt:
     808          792 :             retval = _equalDropSubscriptionStmt(a, b);
     809          792 :             break;
     810         1210 :         case T_WaitStmt:
     811         1210 :             retval = _equalWaitStmt(a, b);
     812         1210 :             break;
     813            0 :         case T_PathKey:
     814            0 :             retval = _equalPathKey(a, b);
     815            0 :             break;
     816            0 :         case T_GroupByOrdering:
     817            0 :             retval = _equalGroupByOrdering(a, b);
     818            0 :             break;
     819          226 :         case T_RestrictInfo:
     820          226 :             retval = _equalRestrictInfo(a, b);
     821          226 :             break;
     822         7472 :         case T_PlaceHolderVar:
     823         7472 :             retval = _equalPlaceHolderVar(a, b);
     824         7472 :             break;
     825            0 :         case T_SpecialJoinInfo:
     826            0 :             retval = _equalSpecialJoinInfo(a, b);
     827            0 :             break;
     828            0 :         case T_AppendRelInfo:
     829            0 :             retval = _equalAppendRelInfo(a, b);
     830            0 :             break;
     831            0 :         case T_PlaceHolderInfo:
     832            0 :             retval = _equalPlaceHolderInfo(a, b);
     833            0 :             break;
     834          160 :         case T_AggClauseInfo:
     835          160 :             retval = _equalAggClauseInfo(a, b);
     836          160 :             break;
     837            0 :         case T_GroupingExprInfo:
     838            0 :             retval = _equalGroupingExprInfo(a, b);
     839            0 :             break;
     840            0 :         case T_SubPlanRTInfo:
     841            0 :             retval = _equalSubPlanRTInfo(a, b);
     842            0 :             break;
     843            0 :         case T_ElidedNode:
     844            0 :             retval = _equalElidedNode(a, b);
     845            0 :             break;
     846        74542 :         case T_Bitmapset:
     847        74542 :             retval = _equalBitmapset(a, b);
     848        74542 :             break;
     849            3 :         case T_ExtensibleNode:
     850            3 :             retval = _equalExtensibleNode(a, b);
     851            3 :             break;
     852       653174 :         case T_Integer:
     853       653174 :             retval = _equalInteger(a, b);
     854       653174 :             break;
     855        16508 :         case T_Float:
     856        16508 :             retval = _equalFloat(a, b);
     857        16508 :             break;
     858       118664 :         case T_Boolean:
     859       118664 :             retval = _equalBoolean(a, b);
     860       118664 :             break;
     861     22389697 :         case T_String:
     862     22389697 :             retval = _equalString(a, b);
     863     22389697 :             break;
     864         5494 :         case T_BitString:
     865         5494 :             retval = _equalBitString(a, b);
     866         5494 :             break;
        

Generated by: LCOV version 2.0-1