LCOV - code coverage report
Current view: top level - src/backend/nodes - equalfuncs.switch.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 798 828 96.4 %
Date: 2025-04-24 12:15:10 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-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     2659186 :         case T_Alias:
      19     2659186 :             retval = _equalAlias(a, b);
      20     2659186 :             break;
      21     1793492 :         case T_RangeVar:
      22     1793492 :             retval = _equalRangeVar(a, b);
      23     1793492 :             break;
      24        1168 :         case T_TableFunc:
      25        1168 :             retval = _equalTableFunc(a, b);
      26        1168 :             break;
      27        7872 :         case T_IntoClause:
      28        7872 :             retval = _equalIntoClause(a, b);
      29        7872 :             break;
      30    17086260 :         case T_Var:
      31    17086260 :             retval = _equalVar(a, b);
      32    17086260 :             break;
      33     2643366 :         case T_Const:
      34     2643366 :             retval = _equalConst(a, b);
      35     2643366 :             break;
      36      171386 :         case T_Param:
      37      171386 :             retval = _equalParam(a, b);
      38      171386 :             break;
      39      101798 :         case T_Aggref:
      40      101798 :             retval = _equalAggref(a, b);
      41      101798 :             break;
      42        1556 :         case T_GroupingFunc:
      43        1556 :             retval = _equalGroupingFunc(a, b);
      44        1556 :             break;
      45        9126 :         case T_WindowFunc:
      46        9126 :             retval = _equalWindowFunc(a, b);
      47        9126 :             break;
      48         204 :         case T_WindowFuncRunCondition:
      49         204 :             retval = _equalWindowFuncRunCondition(a, b);
      50         204 :             break;
      51         768 :         case T_MergeSupportFunc:
      52         768 :             retval = _equalMergeSupportFunc(a, b);
      53         768 :             break;
      54       31078 :         case T_SubscriptingRef:
      55       31078 :             retval = _equalSubscriptingRef(a, b);
      56       31078 :             break;
      57      792240 :         case T_FuncExpr:
      58      792240 :             retval = _equalFuncExpr(a, b);
      59      792240 :             break;
      60      189088 :         case T_NamedArgExpr:
      61      189088 :             retval = _equalNamedArgExpr(a, b);
      62      189088 :             break;
      63     1460820 :         case T_OpExpr:
      64     1460820 :             retval = _equalOpExpr(a, b);
      65     1460820 :             break;
      66        2532 :         case T_DistinctExpr:
      67        2532 :             retval = _equalDistinctExpr(a, b);
      68        2532 :             break;
      69         354 :         case T_NullIfExpr:
      70         354 :             retval = _equalNullIfExpr(a, b);
      71         354 :             break;
      72       66654 :         case T_ScalarArrayOpExpr:
      73       66654 :             retval = _equalScalarArrayOpExpr(a, b);
      74       66654 :             break;
      75      652960 :         case T_BoolExpr:
      76      652960 :             retval = _equalBoolExpr(a, b);
      77      652960 :             break;
      78      201054 :         case T_SubLink:
      79      201054 :             retval = _equalSubLink(a, b);
      80      201054 :             break;
      81        6428 :         case T_SubPlan:
      82        6428 :             retval = _equalSubPlan(a, b);
      83        6428 :             break;
      84           0 :         case T_AlternativeSubPlan:
      85           0 :             retval = _equalAlternativeSubPlan(a, b);
      86           0 :             break;
      87       10890 :         case T_FieldSelect:
      88       10890 :             retval = _equalFieldSelect(a, b);
      89       10890 :             break;
      90         776 :         case T_FieldStore:
      91         776 :             retval = _equalFieldStore(a, b);
      92         776 :             break;
      93      332702 :         case T_RelabelType:
      94      332702 :             retval = _equalRelabelType(a, b);
      95      332702 :             break;
      96       53856 :         case T_CoerceViaIO:
      97       53856 :             retval = _equalCoerceViaIO(a, b);
      98       53856 :             break;
      99       10728 :         case T_ArrayCoerceExpr:
     100       10728 :             retval = _equalArrayCoerceExpr(a, b);
     101       10728 :             break;
     102         132 :         case T_ConvertRowtypeExpr:
     103         132 :             retval = _equalConvertRowtypeExpr(a, b);
     104         132 :             break;
     105       17428 :         case T_CollateExpr:
     106       17428 :             retval = _equalCollateExpr(a, b);
     107       17428 :             break;
     108      188386 :         case T_CaseExpr:
     109      188386 :             retval = _equalCaseExpr(a, b);
     110      188386 :             break;
     111      348532 :         case T_CaseWhen:
     112      348532 :             retval = _equalCaseWhen(a, b);
     113      348532 :             break;
     114       49210 :         case T_CaseTestExpr:
     115       49210 :             retval = _equalCaseTestExpr(a, b);
     116       49210 :             break;
     117       51232 :         case T_ArrayExpr:
     118       51232 :             retval = _equalArrayExpr(a, b);
     119       51232 :             break;
     120       22090 :         case T_RowExpr:
     121       22090 :             retval = _equalRowExpr(a, b);
     122       22090 :             break;
     123         492 :         case T_RowCompareExpr:
     124         492 :             retval = _equalRowCompareExpr(a, b);
     125         492 :             break;
     126       16282 :         case T_CoalesceExpr:
     127       16282 :             retval = _equalCoalesceExpr(a, b);
     128       16282 :             break;
     129        1022 :         case T_MinMaxExpr:
     130        1022 :             retval = _equalMinMaxExpr(a, b);
     131        1022 :             break;
     132       14738 :         case T_SQLValueFunction:
     133       14738 :             retval = _equalSQLValueFunction(a, b);
     134       14738 :             break;
     135        2764 :         case T_XmlExpr:
     136        2764 :             retval = _equalXmlExpr(a, b);
     137        2764 :             break;
     138       28988 :         case T_JsonFormat:
     139       28988 :             retval = _equalJsonFormat(a, b);
     140       28988 :             break;
     141       10464 :         case T_JsonReturning:
     142       10464 :             retval = _equalJsonReturning(a, b);
     143       10464 :             break;
     144       10456 :         case T_JsonValueExpr:
     145       10456 :             retval = _equalJsonValueExpr(a, b);
     146       10456 :             break;
     147        2708 :         case T_JsonConstructorExpr:
     148        2708 :             retval = _equalJsonConstructorExpr(a, b);
     149        2708 :             break;
     150        1388 :         case T_JsonIsPredicate:
     151        1388 :             retval = _equalJsonIsPredicate(a, b);
     152        1388 :             break;
     153       10572 :         case T_JsonBehavior:
     154       10572 :             retval = _equalJsonBehavior(a, b);
     155       10572 :             break;
     156        4784 :         case T_JsonExpr:
     157        4784 :             retval = _equalJsonExpr(a, b);
     158        4784 :             break;
     159        1124 :         case T_JsonTablePath:
     160        1124 :             retval = _equalJsonTablePath(a, b);
     161        1124 :             break;
     162        1124 :         case T_JsonTablePathScan:
     163        1124 :             retval = _equalJsonTablePathScan(a, b);
     164        1124 :             break;
     165         120 :         case T_JsonTableSiblingJoin:
     166         120 :             retval = _equalJsonTableSiblingJoin(a, b);
     167         120 :             break;
     168       78080 :         case T_NullTest:
     169       78080 :             retval = _equalNullTest(a, b);
     170       78080 :             break;
     171        4756 :         case T_BooleanTest:
     172        4756 :             retval = _equalBooleanTest(a, b);
     173        4756 :             break;
     174        5724 :         case T_MergeAction:
     175        5724 :             retval = _equalMergeAction(a, b);
     176        5724 :             break;
     177       71712 :         case T_CoerceToDomain:
     178       71712 :             retval = _equalCoerceToDomain(a, b);
     179       71712 :             break;
     180           0 :         case T_CoerceToDomainValue:
     181           0 :             retval = _equalCoerceToDomainValue(a, b);
     182           0 :             break;
     183        2984 :         case T_SetToDefault:
     184        2984 :             retval = _equalSetToDefault(a, b);
     185        2984 :             break;
     186         992 :         case T_CurrentOfExpr:
     187         992 :             retval = _equalCurrentOfExpr(a, b);
     188         992 :             break;
     189         820 :         case T_NextValueExpr:
     190         820 :             retval = _equalNextValueExpr(a, b);
     191         820 :             break;
     192        3696 :         case T_InferenceElem:
     193        3696 :             retval = _equalInferenceElem(a, b);
     194        3696 :             break;
     195         732 :         case T_ReturningExpr:
     196         732 :             retval = _equalReturningExpr(a, b);
     197         732 :             break;
     198     3203924 :         case T_TargetEntry:
     199     3203924 :             retval = _equalTargetEntry(a, b);
     200     3203924 :             break;
     201     1031384 :         case T_RangeTblRef:
     202     1031384 :             retval = _equalRangeTblRef(a, b);
     203     1031384 :             break;
     204      371204 :         case T_JoinExpr:
     205      371204 :             retval = _equalJoinExpr(a, b);
     206      371204 :             break;
     207     1136344 :         case T_FromExpr:
     208     1136344 :             retval = _equalFromExpr(a, b);
     209     1136344 :             break;
     210        3604 :         case T_OnConflictExpr:
     211        3604 :             retval = _equalOnConflictExpr(a, b);
     212        3604 :             break;
     213     1932294 :         case T_Query:
     214     1932294 :             retval = _equalQuery(a, b);
     215     1932294 :             break;
     216     1697674 :         case T_TypeName:
     217     1697674 :             retval = _equalTypeName(a, b);
     218     1697674 :             break;
     219     4253108 :         case T_ColumnRef:
     220     4253108 :             retval = _equalColumnRef(a, b);
     221     4253108 :             break;
     222      109956 :         case T_ParamRef:
     223      109956 :             retval = _equalParamRef(a, b);
     224      109956 :             break;
     225     1325360 :         case T_A_Expr:
     226     1325360 :             retval = _equalA_Expr(a, b);
     227     1325360 :             break;
     228     3019990 :         case T_A_Const:
     229     3019990 :             retval = _equalA_Const(a, b);
     230     3019990 :             break;
     231      790670 :         case T_TypeCast:
     232      790670 :             retval = _equalTypeCast(a, b);
     233      790670 :             break;
     234       21236 :         case T_CollateClause:
     235       21236 :             retval = _equalCollateClause(a, b);
     236       21236 :             break;
     237      128556 :         case T_RoleSpec:
     238      128556 :             retval = _equalRoleSpec(a, b);
     239      128556 :             break;
     240      828728 :         case T_FuncCall:
     241      828728 :             retval = _equalFuncCall(a, b);
     242      828728 :             break;
     243      134372 :         case T_A_Star:
     244      134372 :             retval = _equalA_Star(a, b);
     245      134372 :             break;
     246       30328 :         case T_A_Indices:
     247       30328 :             retval = _equalA_Indices(a, b);
     248       30328 :             break;
     249       70412 :         case T_A_Indirection:
     250       70412 :             retval = _equalA_Indirection(a, b);
     251       70412 :             break;
     252       14040 :         case T_A_ArrayExpr:
     253       14040 :             retval = _equalA_ArrayExpr(a, b);
     254       14040 :             break;
     255     2691832 :         case T_ResTarget:
     256     2691832 :             retval = _equalResTarget(a, b);
     257     2691832 :             break;
     258         804 :         case T_MultiAssignRef:
     259         804 :             retval = _equalMultiAssignRef(a, b);
     260         804 :             break;
     261      228294 :         case T_SortBy:
     262      228294 :             retval = _equalSortBy(a, b);
     263      228294 :             break;
     264        8344 :         case T_WindowDef:
     265        8344 :             retval = _equalWindowDef(a, b);
     266        8344 :             break;
     267       37120 :         case T_RangeSubselect:
     268       37120 :             retval = _equalRangeSubselect(a, b);
     269       37120 :             break;
     270      113104 :         case T_RangeFunction:
     271      113104 :             retval = _equalRangeFunction(a, b);
     272      113104 :             break;
     273         500 :         case T_RangeTableFunc:
     274         500 :             retval = _equalRangeTableFunc(a, b);
     275         500 :             break;
     276        1812 :         case T_RangeTableFuncCol:
     277        1812 :             retval = _equalRangeTableFuncCol(a, b);
     278        1812 :             break;
     279         576 :         case T_RangeTableSample:
     280         576 :             retval = _equalRangeTableSample(a, b);
     281         576 :             break;
     282      305084 :         case T_ColumnDef:
     283      305084 :             retval = _equalColumnDef(a, b);
     284      305084 :             break;
     285        3096 :         case T_TableLikeClause:
     286        3096 :             retval = _equalTableLikeClause(a, b);
     287        3096 :             break;
     288       40736 :         case T_IndexElem:
     289       40736 :             retval = _equalIndexElem(a, b);
     290       40736 :             break;
     291      697068 :         case T_DefElem:
     292      697068 :             retval = _equalDefElem(a, b);
     293      697068 :             break;
     294        4336 :         case T_LockingClause:
     295        4336 :             retval = _equalLockingClause(a, b);
     296        4336 :             break;
     297         532 :         case T_XmlSerialize:
     298         532 :             retval = _equalXmlSerialize(a, b);
     299         532 :             break;
     300       22416 :         case T_PartitionElem:
     301       22416 :             retval = _equalPartitionElem(a, b);
     302       22416 :             break;
     303       20552 :         case T_PartitionSpec:
     304       20552 :             retval = _equalPartitionSpec(a, b);
     305       20552 :             break;
     306       43088 :         case T_PartitionBoundSpec:
     307       43088 :             retval = _equalPartitionBoundSpec(a, b);
     308       43088 :             break;
     309           0 :         case T_PartitionRangeDatum:
     310           0 :             retval = _equalPartitionRangeDatum(a, b);
     311           0 :             break;
     312       15652 :         case T_PartitionCmd:
     313       15652 :             retval = _equalPartitionCmd(a, b);
     314       15652 :             break;
     315     1377746 :         case T_RangeTblEntry:
     316     1377746 :             retval = _equalRangeTblEntry(a, b);
     317     1377746 :             break;
     318      954298 :         case T_RTEPermissionInfo:
     319      954298 :             retval = _equalRTEPermissionInfo(a, b);
     320      954298 :             break;
     321      108588 :         case T_RangeTblFunction:
     322      108588 :             retval = _equalRangeTblFunction(a, b);
     323      108588 :             break;
     324         440 :         case T_TableSampleClause:
     325         440 :             retval = _equalTableSampleClause(a, b);
     326         440 :             break;
     327        7496 :         case T_WithCheckOption:
     328        7496 :             retval = _equalWithCheckOption(a, b);
     329        7496 :             break;
     330      301132 :         case T_SortGroupClause:
     331      301132 :             retval = _equalSortGroupClause(a, b);
     332      301132 :             break;
     333        8456 :         case T_GroupingSet:
     334        8456 :             retval = _equalGroupingSet(a, b);
     335        8456 :             break;
     336        5356 :         case T_WindowClause:
     337        5356 :             retval = _equalWindowClause(a, b);
     338        5356 :             break;
     339       10396 :         case T_RowMarkClause:
     340       10396 :             retval = _equalRowMarkClause(a, b);
     341       10396 :             break;
     342        6764 :         case T_WithClause:
     343        6764 :             retval = _equalWithClause(a, b);
     344        6764 :             break;
     345        3268 :         case T_InferClause:
     346        3268 :             retval = _equalInferClause(a, b);
     347        3268 :             break;
     348        3748 :         case T_OnConflictClause:
     349        3748 :             retval = _equalOnConflictClause(a, b);
     350        3748 :             break;
     351         420 :         case T_CTESearchClause:
     352         420 :             retval = _equalCTESearchClause(a, b);
     353         420 :             break;
     354         420 :         case T_CTECycleClause:
     355         420 :             retval = _equalCTECycleClause(a, b);
     356         420 :             break;
     357       17248 :         case T_CommonTableExpr:
     358       17248 :             retval = _equalCommonTableExpr(a, b);
     359       17248 :             break;
     360        5968 :         case T_MergeWhenClause:
     361        5968 :             retval = _equalMergeWhenClause(a, b);
     362        5968 :             break;
     363         300 :         case T_ReturningOption:
     364         300 :             retval = _equalReturningOption(a, b);
     365         300 :             break;
     366        6552 :         case T_ReturningClause:
     367        6552 :             retval = _equalReturningClause(a, b);
     368        6552 :             break;
     369        2456 :         case T_TriggerTransition:
     370        2456 :             retval = _equalTriggerTransition(a, b);
     371        2456 :             break;
     372        2972 :         case T_JsonOutput:
     373        2972 :             retval = _equalJsonOutput(a, b);
     374        2972 :             break;
     375        1260 :         case T_JsonArgument:
     376        1260 :             retval = _equalJsonArgument(a, b);
     377        1260 :             break;
     378        3984 :         case T_JsonFuncExpr:
     379        3984 :             retval = _equalJsonFuncExpr(a, b);
     380        3984 :             break;
     381        3944 :         case T_JsonTablePathSpec:
     382        3944 :             retval = _equalJsonTablePathSpec(a, b);
     383        3944 :             break;
     384        1180 :         case T_JsonTable:
     385        1180 :             retval = _equalJsonTable(a, b);
     386        1180 :             break;
     387        3296 :         case T_JsonTableColumn:
     388        3296 :             retval = _equalJsonTableColumn(a, b);
     389        3296 :             break;
     390        1652 :         case T_JsonKeyValue:
     391        1652 :             retval = _equalJsonKeyValue(a, b);
     392        1652 :             break;
     393         328 :         case T_JsonParseExpr:
     394         328 :             retval = _equalJsonParseExpr(a, b);
     395         328 :             break;
     396         224 :         case T_JsonScalarExpr:
     397         224 :             retval = _equalJsonScalarExpr(a, b);
     398         224 :             break;
     399         216 :         case T_JsonSerializeExpr:
     400         216 :             retval = _equalJsonSerializeExpr(a, b);
     401         216 :             break;
     402         892 :         case T_JsonObjectConstructor:
     403         892 :             retval = _equalJsonObjectConstructor(a, b);
     404         892 :             break;
     405         400 :         case T_JsonArrayConstructor:
     406         400 :             retval = _equalJsonArrayConstructor(a, b);
     407         400 :             break;
     408         132 :         case T_JsonArrayQueryConstructor:
     409         132 :             retval = _equalJsonArrayQueryConstructor(a, b);
     410         132 :             break;
     411         744 :         case T_JsonAggConstructor:
     412         744 :             retval = _equalJsonAggConstructor(a, b);
     413         744 :             break;
     414         420 :         case T_JsonObjectAgg:
     415         420 :             retval = _equalJsonObjectAgg(a, b);
     416         420 :             break;
     417         324 :         case T_JsonArrayAgg:
     418         324 :             retval = _equalJsonArrayAgg(a, b);
     419         324 :             break;
     420     1505712 :         case T_RawStmt:
     421     1505712 :             retval = _equalRawStmt(a, b);
     422     1505712 :             break;
     423      146784 :         case T_InsertStmt:
     424      146784 :             retval = _equalInsertStmt(a, b);
     425      146784 :             break;
     426        8908 :         case T_DeleteStmt:
     427        8908 :             retval = _equalDeleteStmt(a, b);
     428        8908 :             break;
     429       27152 :         case T_UpdateStmt:
     430       27152 :             retval = _equalUpdateStmt(a, b);
     431       27152 :             break;
     432        3860 :         case T_MergeStmt:
     433        3860 :             retval = _equalMergeStmt(a, b);
     434        3860 :             break;
     435     1050052 :         case T_SelectStmt:
     436     1050052 :             retval = _equalSelectStmt(a, b);
     437     1050052 :             break;
     438       31202 :         case T_SetOperationStmt:
     439       31202 :             retval = _equalSetOperationStmt(a, b);
     440       31202 :             break;
     441       19136 :         case T_ReturnStmt:
     442       19136 :             retval = _equalReturnStmt(a, b);
     443       19136 :             break;
     444           0 :         case T_PLAssignStmt:
     445           0 :             retval = _equalPLAssignStmt(a, b);
     446           0 :             break;
     447        4256 :         case T_CreateSchemaStmt:
     448        4256 :             retval = _equalCreateSchemaStmt(a, b);
     449        4256 :             break;
     450      129976 :         case T_AlterTableStmt:
     451      129976 :             retval = _equalAlterTableStmt(a, b);
     452      129976 :             break;
     453      134008 :         case T_AlterTableCmd:
     454      134008 :             retval = _equalAlterTableCmd(a, b);
     455      134008 :             break;
     456        1152 :         case T_ATAlterConstraint:
     457        1152 :             retval = _equalATAlterConstraint(a, b);
     458        1152 :             break;
     459        1960 :         case T_ReplicaIdentityStmt:
     460        1960 :             retval = _equalReplicaIdentityStmt(a, b);
     461        1960 :             break;
     462          24 :         case T_AlterCollationStmt:
     463          24 :             retval = _equalAlterCollationStmt(a, b);
     464          24 :             break;
     465        1128 :         case T_AlterDomainStmt:
     466        1128 :             retval = _equalAlterDomainStmt(a, b);
     467        1128 :             break;
     468       81948 :         case T_GrantStmt:
     469       81948 :             retval = _equalGrantStmt(a, b);
     470       81948 :             break;
     471       80636 :         case T_ObjectWithArgs:
     472       80636 :             retval = _equalObjectWithArgs(a, b);
     473       80636 :             break;
     474       77208 :         case T_AccessPriv:
     475       77208 :             retval = _equalAccessPriv(a, b);
     476       77208 :             break;
     477        3628 :         case T_GrantRoleStmt:
     478        3628 :             retval = _equalGrantRoleStmt(a, b);
     479        3628 :             break;
     480         760 :         case T_AlterDefaultPrivilegesStmt:
     481         760 :             retval = _equalAlterDefaultPrivilegesStmt(a, b);
     482         760 :             break;
     483       64072 :         case T_CopyStmt:
     484       64072 :             retval = _equalCopyStmt(a, b);
     485       64072 :             break;
     486      117312 :         case T_VariableSetStmt:
     487      117312 :             retval = _equalVariableSetStmt(a, b);
     488      117312 :             break;
     489        3504 :         case T_VariableShowStmt:
     490        3504 :             retval = _equalVariableShowStmt(a, b);
     491        3504 :             break;
     492      154256 :         case T_CreateStmt:
     493      154256 :             retval = _equalCreateStmt(a, b);
     494      154256 :             break;
     495      146308 :         case T_Constraint:
     496      146308 :             retval = _equalConstraint(a, b);
     497      146308 :             break;
     498         464 :         case T_CreateTableSpaceStmt:
     499         464 :             retval = _equalCreateTableSpaceStmt(a, b);
     500         464 :             break;
     501         256 :         case T_DropTableSpaceStmt:
     502         256 :             retval = _equalDropTableSpaceStmt(a, b);
     503         256 :             break;
     504          96 :         case T_AlterTableSpaceOptionsStmt:
     505          96 :             retval = _equalAlterTableSpaceOptionsStmt(a, b);
     506          96 :             break;
     507         120 :         case T_AlterTableMoveAllStmt:
     508         120 :             retval = _equalAlterTableMoveAllStmt(a, b);
     509         120 :             break;
     510        2064 :         case T_CreateExtensionStmt:
     511        2064 :             retval = _equalCreateExtensionStmt(a, b);
     512        2064 :             break;
     513         140 :         case T_AlterExtensionStmt:
     514         140 :             retval = _equalAlterExtensionStmt(a, b);
     515         140 :             break;
     516         968 :         case T_AlterExtensionContentsStmt:
     517         968 :             retval = _equalAlterExtensionContentsStmt(a, b);
     518         968 :             break;
     519         824 :         case T_CreateFdwStmt:
     520         824 :             retval = _equalCreateFdwStmt(a, b);
     521         824 :             break;
     522         488 :         case T_AlterFdwStmt:
     523         488 :             retval = _equalAlterFdwStmt(a, b);
     524         488 :             break;
     525        1164 :         case T_CreateForeignServerStmt:
     526        1164 :             retval = _equalCreateForeignServerStmt(a, b);
     527        1164 :             break;
     528         876 :         case T_AlterForeignServerStmt:
     529         876 :             retval = _equalAlterForeignServerStmt(a, b);
     530         876 :             break;
     531        1792 :         case T_CreateForeignTableStmt:
     532        1792 :             retval = _equalCreateForeignTableStmt(a, b);
     533        1792 :             break;
     534        1008 :         case T_CreateUserMappingStmt:
     535        1008 :             retval = _equalCreateUserMappingStmt(a, b);
     536        1008 :             break;
     537         440 :         case T_AlterUserMappingStmt:
     538         440 :             retval = _equalAlterUserMappingStmt(a, b);
     539         440 :             break;
     540         504 :         case T_DropUserMappingStmt:
     541         504 :             retval = _equalDropUserMappingStmt(a, b);
     542         504 :             break;
     543         192 :         case T_ImportForeignSchemaStmt:
     544         192 :             retval = _equalImportForeignSchemaStmt(a, b);
     545         192 :             break;
     546        2800 :         case T_CreatePolicyStmt:
     547        2800 :             retval = _equalCreatePolicyStmt(a, b);
     548        2800 :             break;
     549         336 :         case T_AlterPolicyStmt:
     550         336 :             retval = _equalAlterPolicyStmt(a, b);
     551         336 :             break;
     552         256 :         case T_CreateAmStmt:
     553         256 :             retval = _equalCreateAmStmt(a, b);
     554         256 :             break;
     555       13304 :         case T_CreateTrigStmt:
     556       13304 :             retval = _equalCreateTrigStmt(a, b);
     557       13304 :             break;
     558         792 :         case T_CreateEventTrigStmt:
     559         792 :             retval = _equalCreateEventTrigStmt(a, b);
     560         792 :             break;
     561         192 :         case T_AlterEventTrigStmt:
     562         192 :             retval = _equalAlterEventTrigStmt(a, b);
     563         192 :             break;
     564         560 :         case T_CreatePLangStmt:
     565         560 :             retval = _equalCreatePLangStmt(a, b);
     566         560 :             break;
     567        7384 :         case T_CreateRoleStmt:
     568        7384 :             retval = _equalCreateRoleStmt(a, b);
     569        7384 :             break;
     570        1840 :         case T_AlterRoleStmt:
     571        1840 :             retval = _equalAlterRoleStmt(a, b);
     572        1840 :             break;
     573         328 :         case T_AlterRoleSetStmt:
     574         328 :             retval = _equalAlterRoleSetStmt(a, b);
     575         328 :             break;
     576        6872 :         case T_DropRoleStmt:
     577        6872 :             retval = _equalDropRoleStmt(a, b);
     578        6872 :             break;
     579        2936 :         case T_CreateSeqStmt:
     580        2936 :             retval = _equalCreateSeqStmt(a, b);
     581        2936 :             break;
     582         896 :         case T_AlterSeqStmt:
     583         896 :             retval = _equalAlterSeqStmt(a, b);
     584         896 :             break;
     585       37040 :         case T_DefineStmt:
     586       37040 :             retval = _equalDefineStmt(a, b);
     587       37040 :             break;
     588        5896 :         case T_CreateDomainStmt:
     589        5896 :             retval = _equalCreateDomainStmt(a, b);
     590        5896 :             break;
     591        1576 :         case T_CreateOpClassStmt:
     592        1576 :             retval = _equalCreateOpClassStmt(a, b);
     593        1576 :             break;
     594       16360 :         case T_CreateOpClassItem:
     595       16360 :             retval = _equalCreateOpClassItem(a, b);
     596       16360 :             break;
     597         648 :         case T_CreateOpFamilyStmt:
     598         648 :             retval = _equalCreateOpFamilyStmt(a, b);
     599         648 :             break;
     600        2312 :         case T_AlterOpFamilyStmt:
     601        2312 :             retval = _equalAlterOpFamilyStmt(a, b);
     602        2312 :             break;
     603      101268 :         case T_DropStmt:
     604      101268 :             retval = _equalDropStmt(a, b);
     605      101268 :             break;
     606       11692 :         case T_TruncateStmt:
     607       11692 :             retval = _equalTruncateStmt(a, b);
     608       11692 :             break;
     609       27552 :         case T_CommentStmt:
     610       27552 :             retval = _equalCommentStmt(a, b);
     611       27552 :             break;
     612         400 :         case T_SecLabelStmt:
     613         400 :             retval = _equalSecLabelStmt(a, b);
     614         400 :             break;
     615       14672 :         case T_DeclareCursorStmt:
     616       14672 :             retval = _equalDeclareCursorStmt(a, b);
     617       14672 :             break;
     618        8816 :         case T_ClosePortalStmt:
     619        8816 :             retval = _equalClosePortalStmt(a, b);
     620        8816 :             break;
     621       26588 :         case T_FetchStmt:
     622       26588 :             retval = _equalFetchStmt(a, b);
     623       26588 :             break;
     624       26656 :         case T_IndexStmt:
     625       26656 :             retval = _equalIndexStmt(a, b);
     626       26656 :             break;
     627        2620 :         case T_CreateStatsStmt:
     628        2620 :             retval = _equalCreateStatsStmt(a, b);
     629        2620 :             break;
     630        6408 :         case T_StatsElem:
     631        6408 :             retval = _equalStatsElem(a, b);
     632        6408 :             break;
     633         104 :         case T_AlterStatsStmt:
     634         104 :             retval = _equalAlterStatsStmt(a, b);
     635         104 :             break;
     636       97968 :         case T_CreateFunctionStmt:
     637       97968 :             retval = _equalCreateFunctionStmt(a, b);
     638       97968 :             break;
     639      293708 :         case T_FunctionParameter:
     640      293708 :             retval = _equalFunctionParameter(a, b);
     641      293708 :             break;
     642        2688 :         case T_AlterFunctionStmt:
     643        2688 :             retval = _equalAlterFunctionStmt(a, b);
     644        2688 :             break;
     645        4408 :         case T_DoStmt:
     646        4408 :             retval = _equalDoStmt(a, b);
     647        4408 :             break;
     648        1796 :         case T_CallStmt:
     649        1796 :             retval = _equalCallStmt(a, b);
     650        1796 :             break;
     651        5664 :         case T_RenameStmt:
     652        5664 :             retval = _equalRenameStmt(a, b);
     653        5664 :             break;
     654         184 :         case T_AlterObjectDependsStmt:
     655         184 :             retval = _equalAlterObjectDependsStmt(a, b);
     656         184 :             break;
     657        1592 :         case T_AlterObjectSchemaStmt:
     658        1592 :             retval = _equalAlterObjectSchemaStmt(a, b);
     659        1592 :             break;
     660       10020 :         case T_AlterOwnerStmt:
     661       10020 :             retval = _equalAlterOwnerStmt(a, b);
     662       10020 :             break;
     663        2432 :         case T_AlterOperatorStmt:
     664        2432 :             retval = _equalAlterOperatorStmt(a, b);
     665        2432 :             break;
     666         240 :         case T_AlterTypeStmt:
     667         240 :             retval = _equalAlterTypeStmt(a, b);
     668         240 :             break;
     669        4664 :         case T_RuleStmt:
     670        4664 :             retval = _equalRuleStmt(a, b);
     671        4664 :             break;
     672         546 :         case T_NotifyStmt:
     673         546 :             retval = _equalNotifyStmt(a, b);
     674         546 :             break;
     675         296 :         case T_ListenStmt:
     676         296 :             retval = _equalListenStmt(a, b);
     677         296 :             break;
     678         152 :         case T_UnlistenStmt:
     679         152 :             retval = _equalUnlistenStmt(a, b);
     680         152 :             break;
     681      151068 :         case T_TransactionStmt:
     682      151068 :             retval = _equalTransactionStmt(a, b);
     683      151068 :             break;
     684       10568 :         case T_CompositeTypeStmt:
     685       10568 :             retval = _equalCompositeTypeStmt(a, b);
     686       10568 :             break;
     687         824 :         case T_CreateEnumStmt:
     688         824 :             retval = _equalCreateEnumStmt(a, b);
     689         824 :             break;
     690         784 :         case T_CreateRangeStmt:
     691         784 :             retval = _equalCreateRangeStmt(a, b);
     692         784 :             break;
     693        1584 :         case T_AlterEnumStmt:
     694        1584 :             retval = _equalAlterEnumStmt(a, b);
     695        1584 :             break;
     696       66560 :         case T_ViewStmt:
     697       66560 :             retval = _equalViewStmt(a, b);
     698       66560 :             break;
     699         208 :         case T_LoadStmt:
     700         208 :             retval = _equalLoadStmt(a, b);
     701         208 :             break;
     702        3120 :         case T_CreatedbStmt:
     703        3120 :             retval = _equalCreatedbStmt(a, b);
     704        3120 :             break;
     705         304 :         case T_AlterDatabaseStmt:
     706         304 :             retval = _equalAlterDatabaseStmt(a, b);
     707         304 :             break;
     708          24 :         case T_AlterDatabaseRefreshCollStmt:
     709          24 :             retval = _equalAlterDatabaseRefreshCollStmt(a, b);
     710          24 :             break;
     711        4728 :         case T_AlterDatabaseSetStmt:
     712        4728 :             retval = _equalAlterDatabaseSetStmt(a, b);
     713        4728 :             break;
     714         496 :         case T_DropdbStmt:
     715         496 :             retval = _equalDropdbStmt(a, b);
     716         496 :             break;
     717         728 :         case T_AlterSystemStmt:
     718         728 :             retval = _equalAlterSystemStmt(a, b);
     719         728 :             break;
     720         944 :         case T_ClusterStmt:
     721         944 :             retval = _equalClusterStmt(a, b);
     722         944 :             break;
     723       54316 :         case T_VacuumStmt:
     724       54316 :             retval = _equalVacuumStmt(a, b);
     725       54316 :             break;
     726       53404 :         case T_VacuumRelation:
     727       53404 :             retval = _equalVacuumRelation(a, b);
     728       53404 :             break;
     729       78488 :         case T_ExplainStmt:
     730       78488 :             retval = _equalExplainStmt(a, b);
     731       78488 :             break;
     732        7632 :         case T_CreateTableAsStmt:
     733        7632 :             retval = _equalCreateTableAsStmt(a, b);
     734        7632 :             break;
     735        1136 :         case T_RefreshMatViewStmt:
     736        1136 :             retval = _equalRefreshMatViewStmt(a, b);
     737        1136 :             break;
     738         884 :         case T_CheckPointStmt:
     739         884 :             retval = _equalCheckPointStmt(a, b);
     740         884 :             break;
     741         120 :         case T_DiscardStmt:
     742         120 :             retval = _equalDiscardStmt(a, b);
     743         120 :             break;
     744        9912 :         case T_LockStmt:
     745        9912 :             retval = _equalLockStmt(a, b);
     746        9912 :             break;
     747         404 :         case T_ConstraintsSetStmt:
     748         404 :             retval = _equalConstraintsSetStmt(a, b);
     749         404 :             break;
     750        4432 :         case T_ReindexStmt:
     751        4432 :             retval = _equalReindexStmt(a, b);
     752        4432 :             break;
     753         256 :         case T_CreateConversionStmt:
     754         256 :             retval = _equalCreateConversionStmt(a, b);
     755         256 :             break;
     756        1160 :         case T_CreateCastStmt:
     757        1160 :             retval = _equalCreateCastStmt(a, b);
     758        1160 :             break;
     759         208 :         case T_CreateTransformStmt:
     760         208 :             retval = _equalCreateTransformStmt(a, b);
     761         208 :             break;
     762        9280 :         case T_PrepareStmt:
     763        9280 :             retval = _equalPrepareStmt(a, b);
     764        9280 :             break;
     765       81180 :         case T_ExecuteStmt:
     766       81180 :             retval = _equalExecuteStmt(a, b);
     767       81180 :             break;
     768       16240 :         case T_DeallocateStmt:
     769       16240 :             retval = _equalDeallocateStmt(a, b);
     770       16240 :             break;
     771         616 :         case T_DropOwnedStmt:
     772         616 :             retval = _equalDropOwnedStmt(a, b);
     773         616 :             break;
     774         208 :         case T_ReassignOwnedStmt:
     775         208 :             retval = _equalReassignOwnedStmt(a, b);
     776         208 :             break;
     777         160 :         case T_AlterTSDictionaryStmt:
     778         160 :             retval = _equalAlterTSDictionaryStmt(a, b);
     779         160 :             break;
     780       34280 :         case T_AlterTSConfigurationStmt:
     781       34280 :             retval = _equalAlterTSConfigurationStmt(a, b);
     782       34280 :             break;
     783        5536 :         case T_PublicationTable:
     784        5536 :             retval = _equalPublicationTable(a, b);
     785        5536 :             break;
     786        6960 :         case T_PublicationObjSpec:
     787        6960 :             retval = _equalPublicationObjSpec(a, b);
     788        6960 :             break;
     789        3232 :         case T_CreatePublicationStmt:
     790        3232 :             retval = _equalCreatePublicationStmt(a, b);
     791        3232 :             break;
     792        4272 :         case T_AlterPublicationStmt:
     793        4272 :             retval = _equalAlterPublicationStmt(a, b);
     794        4272 :             break;
     795        1792 :         case T_CreateSubscriptionStmt:
     796        1792 :             retval = _equalCreateSubscriptionStmt(a, b);
     797        1792 :             break;
     798        1892 :         case T_AlterSubscriptionStmt:
     799        1892 :             retval = _equalAlterSubscriptionStmt(a, b);
     800        1892 :             break;
     801         912 :         case T_DropSubscriptionStmt:
     802         912 :             retval = _equalDropSubscriptionStmt(a, b);
     803         912 :             break;
     804           0 :         case T_PathKey:
     805           0 :             retval = _equalPathKey(a, b);
     806           0 :             break;
     807           0 :         case T_GroupByOrdering:
     808           0 :             retval = _equalGroupByOrdering(a, b);
     809           0 :             break;
     810         792 :         case T_RestrictInfo:
     811         792 :             retval = _equalRestrictInfo(a, b);
     812         792 :             break;
     813        5938 :         case T_PlaceHolderVar:
     814        5938 :             retval = _equalPlaceHolderVar(a, b);
     815        5938 :             break;
     816           0 :         case T_SpecialJoinInfo:
     817           0 :             retval = _equalSpecialJoinInfo(a, b);
     818           0 :             break;
     819           0 :         case T_AppendRelInfo:
     820           0 :             retval = _equalAppendRelInfo(a, b);
     821           0 :             break;
     822           0 :         case T_PlaceHolderInfo:
     823           0 :             retval = _equalPlaceHolderInfo(a, b);
     824           0 :             break;
     825       56160 :         case T_Bitmapset:
     826       56160 :             retval = _equalBitmapset(a, b);
     827       56160 :             break;
     828           0 :         case T_ExtensibleNode:
     829           0 :             retval = _equalExtensibleNode(a, b);
     830           0 :             break;
     831      952508 :         case T_Integer:
     832      952508 :             retval = _equalInteger(a, b);
     833      952508 :             break;
     834       23968 :         case T_Float:
     835       23968 :             retval = _equalFloat(a, b);
     836       23968 :             break;
     837      207332 :         case T_Boolean:
     838      207332 :             retval = _equalBoolean(a, b);
     839      207332 :             break;
     840    33349296 :         case T_String:
     841    33349296 :             retval = _equalString(a, b);
     842    33348992 :             break;
     843        8136 :         case T_BitString:
     844        8136 :             retval = _equalBitString(a, b);
     845        8136 :             break;

Generated by: LCOV version 1.14