LCOV - code coverage report
Current view: top level - src/backend/nodes - equalfuncs.switch.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 783 816 96.0 %
Date: 2024-09-16 13:12:04 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-2024, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  * NOTES
      10             :  *  ******************************
      11             :  *  *** DO NOT EDIT THIS FILE! ***
      12             :  *  ******************************
      13             :  *
      14             :  *  It has been GENERATED by src/backend/nodes/gen_node_support.pl
      15             :  *
      16             :  *-------------------------------------------------------------------------
      17             :  */
      18     2190990 :         case T_Alias:
      19     2190990 :             retval = _equalAlias(a, b);
      20     2190990 :             break;
      21     1468750 :         case T_RangeVar:
      22     1468750 :             retval = _equalRangeVar(a, b);
      23     1468750 :             break;
      24        1168 :         case T_TableFunc:
      25        1168 :             retval = _equalTableFunc(a, b);
      26        1168 :             break;
      27        7496 :         case T_IntoClause:
      28        7496 :             retval = _equalIntoClause(a, b);
      29        7496 :             break;
      30    12901044 :         case T_Var:
      31    12901044 :             retval = _equalVar(a, b);
      32    12901044 :             break;
      33     2121494 :         case T_Const:
      34     2121494 :             retval = _equalConst(a, b);
      35     2121494 :             break;
      36      289954 :         case T_Param:
      37      289954 :             retval = _equalParam(a, b);
      38      289954 :             break;
      39       99496 :         case T_Aggref:
      40       99496 :             retval = _equalAggref(a, b);
      41       99496 :             break;
      42        1556 :         case T_GroupingFunc:
      43        1556 :             retval = _equalGroupingFunc(a, b);
      44        1556 :             break;
      45        8742 :         case T_WindowFunc:
      46        8742 :             retval = _equalWindowFunc(a, b);
      47        8742 :             break;
      48         198 :         case T_WindowFuncRunCondition:
      49         198 :             retval = _equalWindowFuncRunCondition(a, b);
      50         198 :             break;
      51         624 :         case T_MergeSupportFunc:
      52         624 :             retval = _equalMergeSupportFunc(a, b);
      53         624 :             break;
      54       17014 :         case T_SubscriptingRef:
      55       17014 :             retval = _equalSubscriptingRef(a, b);
      56       17014 :             break;
      57      705816 :         case T_FuncExpr:
      58      705816 :             retval = _equalFuncExpr(a, b);
      59      705816 :             break;
      60      186712 :         case T_NamedArgExpr:
      61      186712 :             retval = _equalNamedArgExpr(a, b);
      62      186712 :             break;
      63     1234728 :         case T_OpExpr:
      64     1234728 :             retval = _equalOpExpr(a, b);
      65     1234728 :             break;
      66        1760 :         case T_DistinctExpr:
      67        1760 :             retval = _equalDistinctExpr(a, b);
      68        1760 :             break;
      69         318 :         case T_NullIfExpr:
      70         318 :             retval = _equalNullIfExpr(a, b);
      71         318 :             break;
      72       58494 :         case T_ScalarArrayOpExpr:
      73       58494 :             retval = _equalScalarArrayOpExpr(a, b);
      74       58494 :             break;
      75      525986 :         case T_BoolExpr:
      76      525986 :             retval = _equalBoolExpr(a, b);
      77      525986 :             break;
      78      149778 :         case T_SubLink:
      79      149778 :             retval = _equalSubLink(a, b);
      80      149778 :             break;
      81        4900 :         case T_SubPlan:
      82        4900 :             retval = _equalSubPlan(a, b);
      83        4900 :             break;
      84           0 :         case T_AlternativeSubPlan:
      85           0 :             retval = _equalAlternativeSubPlan(a, b);
      86           0 :             break;
      87       10446 :         case T_FieldSelect:
      88       10446 :             retval = _equalFieldSelect(a, b);
      89       10446 :             break;
      90         776 :         case T_FieldStore:
      91         776 :             retval = _equalFieldStore(a, b);
      92         776 :             break;
      93      265142 :         case T_RelabelType:
      94      265142 :             retval = _equalRelabelType(a, b);
      95      265142 :             break;
      96       44980 :         case T_CoerceViaIO:
      97       44980 :             retval = _equalCoerceViaIO(a, b);
      98       44980 :             break;
      99        8452 :         case T_ArrayCoerceExpr:
     100        8452 :             retval = _equalArrayCoerceExpr(a, b);
     101        8452 :             break;
     102         132 :         case T_ConvertRowtypeExpr:
     103         132 :             retval = _equalConvertRowtypeExpr(a, b);
     104         132 :             break;
     105       14466 :         case T_CollateExpr:
     106       14466 :             retval = _equalCollateExpr(a, b);
     107       14466 :             break;
     108      205714 :         case T_CaseExpr:
     109      205714 :             retval = _equalCaseExpr(a, b);
     110      205714 :             break;
     111      359646 :         case T_CaseWhen:
     112      359646 :             retval = _equalCaseWhen(a, b);
     113      359646 :             break;
     114       38786 :         case T_CaseTestExpr:
     115       38786 :             retval = _equalCaseTestExpr(a, b);
     116       38786 :             break;
     117       49772 :         case T_ArrayExpr:
     118       49772 :             retval = _equalArrayExpr(a, b);
     119       49772 :             break;
     120       20924 :         case T_RowExpr:
     121       20924 :             retval = _equalRowExpr(a, b);
     122       20924 :             break;
     123         372 :         case T_RowCompareExpr:
     124         372 :             retval = _equalRowCompareExpr(a, b);
     125         372 :             break;
     126       14790 :         case T_CoalesceExpr:
     127       14790 :             retval = _equalCoalesceExpr(a, b);
     128       14790 :             break;
     129        1094 :         case T_MinMaxExpr:
     130        1094 :             retval = _equalMinMaxExpr(a, b);
     131        1094 :             break;
     132       13080 :         case T_SQLValueFunction:
     133       13080 :             retval = _equalSQLValueFunction(a, b);
     134       13080 :             break;
     135        2708 :         case T_XmlExpr:
     136        2708 :             retval = _equalXmlExpr(a, b);
     137        2708 :             break;
     138       28292 :         case T_JsonFormat:
     139       28292 :             retval = _equalJsonFormat(a, b);
     140       28292 :             break;
     141       10116 :         case T_JsonReturning:
     142       10116 :             retval = _equalJsonReturning(a, b);
     143       10116 :             break;
     144       10156 :         case T_JsonValueExpr:
     145       10156 :             retval = _equalJsonValueExpr(a, b);
     146       10156 :             break;
     147        2468 :         case T_JsonConstructorExpr:
     148        2468 :             retval = _equalJsonConstructorExpr(a, b);
     149        2468 :             break;
     150        1388 :         case T_JsonIsPredicate:
     151        1388 :             retval = _equalJsonIsPredicate(a, b);
     152        1388 :             break;
     153       10500 :         case T_JsonBehavior:
     154       10500 :             retval = _equalJsonBehavior(a, b);
     155       10500 :             break;
     156        4748 :         case T_JsonExpr:
     157        4748 :             retval = _equalJsonExpr(a, b);
     158        4748 :             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       61850 :         case T_NullTest:
     169       61850 :             retval = _equalNullTest(a, b);
     170       61850 :             break;
     171        4036 :         case T_BooleanTest:
     172        4036 :             retval = _equalBooleanTest(a, b);
     173        4036 :             break;
     174        5444 :         case T_MergeAction:
     175        5444 :             retval = _equalMergeAction(a, b);
     176        5444 :             break;
     177       63910 :         case T_CoerceToDomain:
     178       63910 :             retval = _equalCoerceToDomain(a, b);
     179       63910 :             break;
     180           0 :         case T_CoerceToDomainValue:
     181           0 :             retval = _equalCoerceToDomainValue(a, b);
     182           0 :             break;
     183        2688 :         case T_SetToDefault:
     184        2688 :             retval = _equalSetToDefault(a, b);
     185        2688 :             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        3096 :         case T_InferenceElem:
     193        3096 :             retval = _equalInferenceElem(a, b);
     194        3096 :             break;
     195     2668694 :         case T_TargetEntry:
     196     2668694 :             retval = _equalTargetEntry(a, b);
     197     2668694 :             break;
     198      850176 :         case T_RangeTblRef:
     199      850176 :             retval = _equalRangeTblRef(a, b);
     200      850176 :             break;
     201      293258 :         case T_JoinExpr:
     202      293258 :             retval = _equalJoinExpr(a, b);
     203      293258 :             break;
     204     1036564 :         case T_FromExpr:
     205     1036564 :             retval = _equalFromExpr(a, b);
     206     1036564 :             break;
     207        2860 :         case T_OnConflictExpr:
     208        2860 :             retval = _equalOnConflictExpr(a, b);
     209        2860 :             break;
     210     1693744 :         case T_Query:
     211     1693744 :             retval = _equalQuery(a, b);
     212     1693744 :             break;
     213     1361890 :         case T_TypeName:
     214     1361890 :             retval = _equalTypeName(a, b);
     215     1361890 :             break;
     216     3359450 :         case T_ColumnRef:
     217     3359450 :             retval = _equalColumnRef(a, b);
     218     3359450 :             break;
     219      294808 :         case T_ParamRef:
     220      294808 :             retval = _equalParamRef(a, b);
     221      294808 :             break;
     222     1177444 :         case T_A_Expr:
     223     1177444 :             retval = _equalA_Expr(a, b);
     224     1177444 :             break;
     225     2498558 :         case T_A_Const:
     226     2498558 :             retval = _equalA_Const(a, b);
     227     2498558 :             break;
     228      593650 :         case T_TypeCast:
     229      593650 :             retval = _equalTypeCast(a, b);
     230      593650 :             break;
     231       17564 :         case T_CollateClause:
     232       17564 :             retval = _equalCollateClause(a, b);
     233       17564 :             break;
     234       98876 :         case T_RoleSpec:
     235       98876 :             retval = _equalRoleSpec(a, b);
     236       98876 :             break;
     237      740692 :         case T_FuncCall:
     238      740692 :             retval = _equalFuncCall(a, b);
     239      740692 :             break;
     240      110808 :         case T_A_Star:
     241      110808 :             retval = _equalA_Star(a, b);
     242      110808 :             break;
     243       23296 :         case T_A_Indices:
     244       23296 :             retval = _equalA_Indices(a, b);
     245       23296 :             break;
     246       55588 :         case T_A_Indirection:
     247       55588 :             retval = _equalA_Indirection(a, b);
     248       55588 :             break;
     249       12844 :         case T_A_ArrayExpr:
     250       12844 :             retval = _equalA_ArrayExpr(a, b);
     251       12844 :             break;
     252     2230460 :         case T_ResTarget:
     253     2230460 :             retval = _equalResTarget(a, b);
     254     2230460 :             break;
     255         804 :         case T_MultiAssignRef:
     256         804 :             retval = _equalMultiAssignRef(a, b);
     257         804 :             break;
     258      171238 :         case T_SortBy:
     259      171238 :             retval = _equalSortBy(a, b);
     260      171238 :             break;
     261        8108 :         case T_WindowDef:
     262        8108 :             retval = _equalWindowDef(a, b);
     263        8108 :             break;
     264       32692 :         case T_RangeSubselect:
     265       32692 :             retval = _equalRangeSubselect(a, b);
     266       32692 :             break;
     267       85136 :         case T_RangeFunction:
     268       85136 :             retval = _equalRangeFunction(a, b);
     269       85136 :             break;
     270         484 :         case T_RangeTableFunc:
     271         484 :             retval = _equalRangeTableFunc(a, b);
     272         484 :             break;
     273        1740 :         case T_RangeTableFuncCol:
     274        1740 :             retval = _equalRangeTableFuncCol(a, b);
     275        1740 :             break;
     276         548 :         case T_RangeTableSample:
     277         548 :             retval = _equalRangeTableSample(a, b);
     278         548 :             break;
     279      256132 :         case T_ColumnDef:
     280      256132 :             retval = _equalColumnDef(a, b);
     281      256132 :             break;
     282        2808 :         case T_TableLikeClause:
     283        2808 :             retval = _equalTableLikeClause(a, b);
     284        2808 :             break;
     285       36404 :         case T_IndexElem:
     286       36404 :             retval = _equalIndexElem(a, b);
     287       36404 :             break;
     288      583200 :         case T_DefElem:
     289      583200 :             retval = _equalDefElem(a, b);
     290      583200 :             break;
     291        4216 :         case T_LockingClause:
     292        4216 :             retval = _equalLockingClause(a, b);
     293        4216 :             break;
     294         436 :         case T_XmlSerialize:
     295         436 :             retval = _equalXmlSerialize(a, b);
     296         436 :             break;
     297       20344 :         case T_PartitionElem:
     298       20344 :             retval = _equalPartitionElem(a, b);
     299       20344 :             break;
     300       18592 :         case T_PartitionSpec:
     301       18592 :             retval = _equalPartitionSpec(a, b);
     302       18592 :             break;
     303       39088 :         case T_PartitionBoundSpec:
     304       39088 :             retval = _equalPartitionBoundSpec(a, b);
     305       39088 :             break;
     306           0 :         case T_PartitionRangeDatum:
     307           0 :             retval = _equalPartitionRangeDatum(a, b);
     308           0 :             break;
     309       12604 :         case T_PartitionCmd:
     310       12604 :             retval = _equalPartitionCmd(a, b);
     311       12604 :             break;
     312     1151574 :         case T_RangeTblEntry:
     313     1151574 :             retval = _equalRangeTblEntry(a, b);
     314     1151574 :             break;
     315      821622 :         case T_RTEPermissionInfo:
     316      821622 :             retval = _equalRTEPermissionInfo(a, b);
     317      821622 :             break;
     318       83456 :         case T_RangeTblFunction:
     319       83456 :             retval = _equalRangeTblFunction(a, b);
     320       83456 :             break;
     321         428 :         case T_TableSampleClause:
     322         428 :             retval = _equalTableSampleClause(a, b);
     323         428 :             break;
     324        7298 :         case T_WithCheckOption:
     325        7298 :             retval = _equalWithCheckOption(a, b);
     326        7298 :             break;
     327      233222 :         case T_SortGroupClause:
     328      233222 :             retval = _equalSortGroupClause(a, b);
     329      233222 :             break;
     330        8120 :         case T_GroupingSet:
     331        8120 :             retval = _equalGroupingSet(a, b);
     332        8120 :             break;
     333        5188 :         case T_WindowClause:
     334        5188 :             retval = _equalWindowClause(a, b);
     335        5188 :             break;
     336        9608 :         case T_RowMarkClause:
     337        9608 :             retval = _equalRowMarkClause(a, b);
     338        9608 :             break;
     339        5748 :         case T_WithClause:
     340        5748 :             retval = _equalWithClause(a, b);
     341        5748 :             break;
     342        2668 :         case T_InferClause:
     343        2668 :             retval = _equalInferClause(a, b);
     344        2668 :             break;
     345        3004 :         case T_OnConflictClause:
     346        3004 :             retval = _equalOnConflictClause(a, b);
     347        3004 :             break;
     348         420 :         case T_CTESearchClause:
     349         420 :             retval = _equalCTESearchClause(a, b);
     350         420 :             break;
     351         420 :         case T_CTECycleClause:
     352         420 :             retval = _equalCTECycleClause(a, b);
     353         420 :             break;
     354       14596 :         case T_CommonTableExpr:
     355       14596 :             retval = _equalCommonTableExpr(a, b);
     356       14596 :             break;
     357        5672 :         case T_MergeWhenClause:
     358        5672 :             retval = _equalMergeWhenClause(a, b);
     359        5672 :             break;
     360        2248 :         case T_TriggerTransition:
     361        2248 :             retval = _equalTriggerTransition(a, b);
     362        2248 :             break;
     363        2900 :         case T_JsonOutput:
     364        2900 :             retval = _equalJsonOutput(a, b);
     365        2900 :             break;
     366        1224 :         case T_JsonArgument:
     367        1224 :             retval = _equalJsonArgument(a, b);
     368        1224 :             break;
     369        3948 :         case T_JsonFuncExpr:
     370        3948 :             retval = _equalJsonFuncExpr(a, b);
     371        3948 :             break;
     372        3944 :         case T_JsonTablePathSpec:
     373        3944 :             retval = _equalJsonTablePathSpec(a, b);
     374        3944 :             break;
     375        1180 :         case T_JsonTable:
     376        1180 :             retval = _equalJsonTable(a, b);
     377        1180 :             break;
     378        3296 :         case T_JsonTableColumn:
     379        3296 :             retval = _equalJsonTableColumn(a, b);
     380        3296 :             break;
     381        1496 :         case T_JsonKeyValue:
     382        1496 :             retval = _equalJsonKeyValue(a, b);
     383        1496 :             break;
     384         328 :         case T_JsonParseExpr:
     385         328 :             retval = _equalJsonParseExpr(a, b);
     386         328 :             break;
     387         224 :         case T_JsonScalarExpr:
     388         224 :             retval = _equalJsonScalarExpr(a, b);
     389         224 :             break;
     390         216 :         case T_JsonSerializeExpr:
     391         216 :             retval = _equalJsonSerializeExpr(a, b);
     392         216 :             break;
     393         808 :         case T_JsonObjectConstructor:
     394         808 :             retval = _equalJsonObjectConstructor(a, b);
     395         808 :             break;
     396         400 :         case T_JsonArrayConstructor:
     397         400 :             retval = _equalJsonArrayConstructor(a, b);
     398         400 :             break;
     399         120 :         case T_JsonArrayQueryConstructor:
     400         120 :             retval = _equalJsonArrayQueryConstructor(a, b);
     401         120 :             break;
     402         672 :         case T_JsonAggConstructor:
     403         672 :             retval = _equalJsonAggConstructor(a, b);
     404         672 :             break;
     405         348 :         case T_JsonObjectAgg:
     406         348 :             retval = _equalJsonObjectAgg(a, b);
     407         348 :             break;
     408         324 :         case T_JsonArrayAgg:
     409         324 :             retval = _equalJsonArrayAgg(a, b);
     410         324 :             break;
     411     1381484 :         case T_RawStmt:
     412     1381484 :             retval = _equalRawStmt(a, b);
     413     1381484 :             break;
     414      139556 :         case T_InsertStmt:
     415      139556 :             retval = _equalInsertStmt(a, b);
     416      139556 :             break;
     417        8212 :         case T_DeleteStmt:
     418        8212 :             retval = _equalDeleteStmt(a, b);
     419        8212 :             break;
     420       23924 :         case T_UpdateStmt:
     421       23924 :             retval = _equalUpdateStmt(a, b);
     422       23924 :             break;
     423        3652 :         case T_MergeStmt:
     424        3652 :             retval = _equalMergeStmt(a, b);
     425        3652 :             break;
     426      975604 :         case T_SelectStmt:
     427      975604 :             retval = _equalSelectStmt(a, b);
     428      975604 :             break;
     429       20474 :         case T_SetOperationStmt:
     430       20474 :             retval = _equalSetOperationStmt(a, b);
     431       20474 :             break;
     432       15224 :         case T_ReturnStmt:
     433       15224 :             retval = _equalReturnStmt(a, b);
     434       15224 :             break;
     435           0 :         case T_PLAssignStmt:
     436           0 :             retval = _equalPLAssignStmt(a, b);
     437           0 :             break;
     438        3904 :         case T_CreateSchemaStmt:
     439        3904 :             retval = _equalCreateSchemaStmt(a, b);
     440        3904 :             break;
     441      100460 :         case T_AlterTableStmt:
     442      100460 :             retval = _equalAlterTableStmt(a, b);
     443      100460 :             break;
     444        1696 :         case T_ReplicaIdentityStmt:
     445        1696 :             retval = _equalReplicaIdentityStmt(a, b);
     446        1696 :             break;
     447      103748 :         case T_AlterTableCmd:
     448      103748 :             retval = _equalAlterTableCmd(a, b);
     449      103748 :             break;
     450          24 :         case T_AlterCollationStmt:
     451          24 :             retval = _equalAlterCollationStmt(a, b);
     452          24 :             break;
     453        1080 :         case T_AlterDomainStmt:
     454        1080 :             retval = _equalAlterDomainStmt(a, b);
     455        1080 :             break;
     456       64388 :         case T_GrantStmt:
     457       64388 :             retval = _equalGrantStmt(a, b);
     458       64388 :             break;
     459       67420 :         case T_ObjectWithArgs:
     460       67420 :             retval = _equalObjectWithArgs(a, b);
     461       67420 :             break;
     462       61144 :         case T_AccessPriv:
     463       61144 :             retval = _equalAccessPriv(a, b);
     464       61144 :             break;
     465        3468 :         case T_GrantRoleStmt:
     466        3468 :             retval = _equalGrantRoleStmt(a, b);
     467        3468 :             break;
     468         640 :         case T_AlterDefaultPrivilegesStmt:
     469         640 :             retval = _equalAlterDefaultPrivilegesStmt(a, b);
     470         640 :             break;
     471       37504 :         case T_CopyStmt:
     472       37504 :             retval = _equalCopyStmt(a, b);
     473       37504 :             break;
     474       99660 :         case T_VariableSetStmt:
     475       99660 :             retval = _equalVariableSetStmt(a, b);
     476       99660 :             break;
     477        3368 :         case T_VariableShowStmt:
     478        3368 :             retval = _equalVariableShowStmt(a, b);
     479        3368 :             break;
     480      133724 :         case T_CreateStmt:
     481      133724 :             retval = _equalCreateStmt(a, b);
     482      133724 :             break;
     483      115596 :         case T_Constraint:
     484      115596 :             retval = _equalConstraint(a, b);
     485      115596 :             break;
     486         440 :         case T_CreateTableSpaceStmt:
     487         440 :             retval = _equalCreateTableSpaceStmt(a, b);
     488         440 :             break;
     489         256 :         case T_DropTableSpaceStmt:
     490         256 :             retval = _equalDropTableSpaceStmt(a, b);
     491         256 :             break;
     492          96 :         case T_AlterTableSpaceOptionsStmt:
     493          96 :             retval = _equalAlterTableSpaceOptionsStmt(a, b);
     494          96 :             break;
     495         120 :         case T_AlterTableMoveAllStmt:
     496         120 :             retval = _equalAlterTableMoveAllStmt(a, b);
     497         120 :             break;
     498        1640 :         case T_CreateExtensionStmt:
     499        1640 :             retval = _equalCreateExtensionStmt(a, b);
     500        1640 :             break;
     501         100 :         case T_AlterExtensionStmt:
     502         100 :             retval = _equalAlterExtensionStmt(a, b);
     503         100 :             break;
     504         808 :         case T_AlterExtensionContentsStmt:
     505         808 :             retval = _equalAlterExtensionContentsStmt(a, b);
     506         808 :             break;
     507         752 :         case T_CreateFdwStmt:
     508         752 :             retval = _equalCreateFdwStmt(a, b);
     509         752 :             break;
     510         488 :         case T_AlterFdwStmt:
     511         488 :             retval = _equalAlterFdwStmt(a, b);
     512         488 :             break;
     513        1060 :         case T_CreateForeignServerStmt:
     514        1060 :             retval = _equalCreateForeignServerStmt(a, b);
     515        1060 :             break;
     516         876 :         case T_AlterForeignServerStmt:
     517         876 :             retval = _equalAlterForeignServerStmt(a, b);
     518         876 :             break;
     519        1672 :         case T_CreateForeignTableStmt:
     520        1672 :             retval = _equalCreateForeignTableStmt(a, b);
     521        1672 :             break;
     522         952 :         case T_CreateUserMappingStmt:
     523         952 :             retval = _equalCreateUserMappingStmt(a, b);
     524         952 :             break;
     525         440 :         case T_AlterUserMappingStmt:
     526         440 :             retval = _equalAlterUserMappingStmt(a, b);
     527         440 :             break;
     528         504 :         case T_DropUserMappingStmt:
     529         504 :             retval = _equalDropUserMappingStmt(a, b);
     530         504 :             break;
     531         176 :         case T_ImportForeignSchemaStmt:
     532         176 :             retval = _equalImportForeignSchemaStmt(a, b);
     533         176 :             break;
     534        2632 :         case T_CreatePolicyStmt:
     535        2632 :             retval = _equalCreatePolicyStmt(a, b);
     536        2632 :             break;
     537         336 :         case T_AlterPolicyStmt:
     538         336 :             retval = _equalAlterPolicyStmt(a, b);
     539         336 :             break;
     540         248 :         case T_CreateAmStmt:
     541         248 :             retval = _equalCreateAmStmt(a, b);
     542         248 :             break;
     543       12424 :         case T_CreateTrigStmt:
     544       12424 :             retval = _equalCreateTrigStmt(a, b);
     545       12424 :             break;
     546         784 :         case T_CreateEventTrigStmt:
     547         784 :             retval = _equalCreateEventTrigStmt(a, b);
     548         784 :             break;
     549         192 :         case T_AlterEventTrigStmt:
     550         192 :             retval = _equalAlterEventTrigStmt(a, b);
     551         192 :             break;
     552         488 :         case T_CreatePLangStmt:
     553         488 :             retval = _equalCreatePLangStmt(a, b);
     554         488 :             break;
     555        6840 :         case T_CreateRoleStmt:
     556        6840 :             retval = _equalCreateRoleStmt(a, b);
     557        6840 :             break;
     558        1688 :         case T_AlterRoleStmt:
     559        1688 :             retval = _equalAlterRoleStmt(a, b);
     560        1688 :             break;
     561         312 :         case T_AlterRoleSetStmt:
     562         312 :             retval = _equalAlterRoleSetStmt(a, b);
     563         312 :             break;
     564        6648 :         case T_DropRoleStmt:
     565        6648 :             retval = _equalDropRoleStmt(a, b);
     566        6648 :             break;
     567        2560 :         case T_CreateSeqStmt:
     568        2560 :             retval = _equalCreateSeqStmt(a, b);
     569        2560 :             break;
     570         744 :         case T_AlterSeqStmt:
     571         744 :             retval = _equalAlterSeqStmt(a, b);
     572         744 :             break;
     573       31360 :         case T_DefineStmt:
     574       31360 :             retval = _equalDefineStmt(a, b);
     575       31360 :             break;
     576        4776 :         case T_CreateDomainStmt:
     577        4776 :             retval = _equalCreateDomainStmt(a, b);
     578        4776 :             break;
     579        1528 :         case T_CreateOpClassStmt:
     580        1528 :             retval = _equalCreateOpClassStmt(a, b);
     581        1528 :             break;
     582       15728 :         case T_CreateOpClassItem:
     583       15728 :             retval = _equalCreateOpClassItem(a, b);
     584       15728 :             break;
     585         592 :         case T_CreateOpFamilyStmt:
     586         592 :             retval = _equalCreateOpFamilyStmt(a, b);
     587         592 :             break;
     588        1848 :         case T_AlterOpFamilyStmt:
     589        1848 :             retval = _equalAlterOpFamilyStmt(a, b);
     590        1848 :             break;
     591       94180 :         case T_DropStmt:
     592       94180 :             retval = _equalDropStmt(a, b);
     593       94180 :             break;
     594        5468 :         case T_TruncateStmt:
     595        5468 :             retval = _equalTruncateStmt(a, b);
     596        5468 :             break;
     597       22144 :         case T_CommentStmt:
     598       22144 :             retval = _equalCommentStmt(a, b);
     599       22144 :             break;
     600         400 :         case T_SecLabelStmt:
     601         400 :             retval = _equalSecLabelStmt(a, b);
     602         400 :             break;
     603       11024 :         case T_DeclareCursorStmt:
     604       11024 :             retval = _equalDeclareCursorStmt(a, b);
     605       11024 :             break;
     606        8680 :         case T_ClosePortalStmt:
     607        8680 :             retval = _equalClosePortalStmt(a, b);
     608        8680 :             break;
     609       22824 :         case T_FetchStmt:
     610       22824 :             retval = _equalFetchStmt(a, b);
     611       22824 :             break;
     612       24096 :         case T_IndexStmt:
     613       24096 :             retval = _equalIndexStmt(a, b);
     614       24096 :             break;
     615        2244 :         case T_CreateStatsStmt:
     616        2244 :             retval = _equalCreateStatsStmt(a, b);
     617        2244 :             break;
     618        5816 :         case T_StatsElem:
     619        5816 :             retval = _equalStatsElem(a, b);
     620        5816 :             break;
     621         104 :         case T_AlterStatsStmt:
     622         104 :             retval = _equalAlterStatsStmt(a, b);
     623         104 :             break;
     624       82764 :         case T_CreateFunctionStmt:
     625       82764 :             retval = _equalCreateFunctionStmt(a, b);
     626       82764 :             break;
     627      246040 :         case T_FunctionParameter:
     628      246040 :             retval = _equalFunctionParameter(a, b);
     629      246040 :             break;
     630        2528 :         case T_AlterFunctionStmt:
     631        2528 :             retval = _equalAlterFunctionStmt(a, b);
     632        2528 :             break;
     633        4312 :         case T_DoStmt:
     634        4312 :             retval = _equalDoStmt(a, b);
     635        4312 :             break;
     636        1824 :         case T_CallStmt:
     637        1824 :             retval = _equalCallStmt(a, b);
     638        1824 :             break;
     639        5520 :         case T_RenameStmt:
     640        5520 :             retval = _equalRenameStmt(a, b);
     641        5520 :             break;
     642         184 :         case T_AlterObjectDependsStmt:
     643         184 :             retval = _equalAlterObjectDependsStmt(a, b);
     644         184 :             break;
     645        1592 :         case T_AlterObjectSchemaStmt:
     646        1592 :             retval = _equalAlterObjectSchemaStmt(a, b);
     647        1592 :             break;
     648        6196 :         case T_AlterOwnerStmt:
     649        6196 :             retval = _equalAlterOwnerStmt(a, b);
     650        6196 :             break;
     651        2432 :         case T_AlterOperatorStmt:
     652        2432 :             retval = _equalAlterOperatorStmt(a, b);
     653        2432 :             break;
     654         240 :         case T_AlterTypeStmt:
     655         240 :             retval = _equalAlterTypeStmt(a, b);
     656         240 :             break;
     657        4112 :         case T_RuleStmt:
     658        4112 :             retval = _equalRuleStmt(a, b);
     659        4112 :             break;
     660         502 :         case T_NotifyStmt:
     661         502 :             retval = _equalNotifyStmt(a, b);
     662         502 :             break;
     663         296 :         case T_ListenStmt:
     664         296 :             retval = _equalListenStmt(a, b);
     665         296 :             break;
     666         152 :         case T_UnlistenStmt:
     667         152 :             retval = _equalUnlistenStmt(a, b);
     668         152 :             break;
     669      138132 :         case T_TransactionStmt:
     670      138132 :             retval = _equalTransactionStmt(a, b);
     671      138132 :             break;
     672        2776 :         case T_CompositeTypeStmt:
     673        2776 :             retval = _equalCompositeTypeStmt(a, b);
     674        2776 :             break;
     675         768 :         case T_CreateEnumStmt:
     676         768 :             retval = _equalCreateEnumStmt(a, b);
     677         768 :             break;
     678         624 :         case T_CreateRangeStmt:
     679         624 :             retval = _equalCreateRangeStmt(a, b);
     680         624 :             break;
     681        1576 :         case T_AlterEnumStmt:
     682        1576 :             retval = _equalAlterEnumStmt(a, b);
     683        1576 :             break;
     684       54760 :         case T_ViewStmt:
     685       54760 :             retval = _equalViewStmt(a, b);
     686       54760 :             break;
     687         232 :         case T_LoadStmt:
     688         232 :             retval = _equalLoadStmt(a, b);
     689         232 :             break;
     690        2584 :         case T_CreatedbStmt:
     691        2584 :             retval = _equalCreatedbStmt(a, b);
     692        2584 :             break;
     693         184 :         case T_AlterDatabaseStmt:
     694         184 :             retval = _equalAlterDatabaseStmt(a, b);
     695         184 :             break;
     696          24 :         case T_AlterDatabaseRefreshCollStmt:
     697          24 :             retval = _equalAlterDatabaseRefreshCollStmt(a, b);
     698          24 :             break;
     699        4280 :         case T_AlterDatabaseSetStmt:
     700        4280 :             retval = _equalAlterDatabaseSetStmt(a, b);
     701        4280 :             break;
     702         400 :         case T_DropdbStmt:
     703         400 :             retval = _equalDropdbStmt(a, b);
     704         400 :             break;
     705         664 :         case T_AlterSystemStmt:
     706         664 :             retval = _equalAlterSystemStmt(a, b);
     707         664 :             break;
     708         952 :         case T_ClusterStmt:
     709         952 :             retval = _equalClusterStmt(a, b);
     710         952 :             break;
     711       41680 :         case T_VacuumStmt:
     712       41680 :             retval = _equalVacuumStmt(a, b);
     713       41680 :             break;
     714       41096 :         case T_VacuumRelation:
     715       41096 :             retval = _equalVacuumRelation(a, b);
     716       41096 :             break;
     717       71704 :         case T_ExplainStmt:
     718       71704 :             retval = _equalExplainStmt(a, b);
     719       71704 :             break;
     720        7256 :         case T_CreateTableAsStmt:
     721        7256 :             retval = _equalCreateTableAsStmt(a, b);
     722        7256 :             break;
     723        1032 :         case T_RefreshMatViewStmt:
     724        1032 :             retval = _equalRefreshMatViewStmt(a, b);
     725        1032 :             break;
     726         784 :         case T_CheckPointStmt:
     727         784 :             retval = _equalCheckPointStmt(a, b);
     728         784 :             break;
     729         120 :         case T_DiscardStmt:
     730         120 :             retval = _equalDiscardStmt(a, b);
     731         120 :             break;
     732        4288 :         case T_LockStmt:
     733        4288 :             retval = _equalLockStmt(a, b);
     734        4288 :             break;
     735         404 :         case T_ConstraintsSetStmt:
     736         404 :             retval = _equalConstraintsSetStmt(a, b);
     737         404 :             break;
     738        4256 :         case T_ReindexStmt:
     739        4256 :             retval = _equalReindexStmt(a, b);
     740        4256 :             break;
     741         256 :         case T_CreateConversionStmt:
     742         256 :             retval = _equalCreateConversionStmt(a, b);
     743         256 :             break;
     744        1080 :         case T_CreateCastStmt:
     745        1080 :             retval = _equalCreateCastStmt(a, b);
     746        1080 :             break;
     747         200 :         case T_CreateTransformStmt:
     748         200 :             retval = _equalCreateTransformStmt(a, b);
     749         200 :             break;
     750        6752 :         case T_PrepareStmt:
     751        6752 :             retval = _equalPrepareStmt(a, b);
     752        6752 :             break;
     753       61348 :         case T_ExecuteStmt:
     754       61348 :             retval = _equalExecuteStmt(a, b);
     755       61348 :             break;
     756       16144 :         case T_DeallocateStmt:
     757       16144 :             retval = _equalDeallocateStmt(a, b);
     758       16144 :             break;
     759         592 :         case T_DropOwnedStmt:
     760         592 :             retval = _equalDropOwnedStmt(a, b);
     761         592 :             break;
     762         160 :         case T_ReassignOwnedStmt:
     763         160 :             retval = _equalReassignOwnedStmt(a, b);
     764         160 :             break;
     765         160 :         case T_AlterTSDictionaryStmt:
     766         160 :             retval = _equalAlterTSDictionaryStmt(a, b);
     767         160 :             break;
     768       26496 :         case T_AlterTSConfigurationStmt:
     769       26496 :             retval = _equalAlterTSConfigurationStmt(a, b);
     770       26496 :             break;
     771        5136 :         case T_PublicationTable:
     772        5136 :             retval = _equalPublicationTable(a, b);
     773        5136 :             break;
     774        6560 :         case T_PublicationObjSpec:
     775        6560 :             retval = _equalPublicationObjSpec(a, b);
     776        6560 :             break;
     777        2736 :         case T_CreatePublicationStmt:
     778        2736 :             retval = _equalCreatePublicationStmt(a, b);
     779        2736 :             break;
     780        4144 :         case T_AlterPublicationStmt:
     781        4144 :             retval = _equalAlterPublicationStmt(a, b);
     782        4144 :             break;
     783        1672 :         case T_CreateSubscriptionStmt:
     784        1672 :             retval = _equalCreateSubscriptionStmt(a, b);
     785        1672 :             break;
     786        1836 :         case T_AlterSubscriptionStmt:
     787        1836 :             retval = _equalAlterSubscriptionStmt(a, b);
     788        1836 :             break;
     789         776 :         case T_DropSubscriptionStmt:
     790         776 :             retval = _equalDropSubscriptionStmt(a, b);
     791         776 :             break;
     792           0 :         case T_PathKey:
     793           0 :             retval = _equalPathKey(a, b);
     794           0 :             break;
     795           0 :         case T_GroupByOrdering:
     796           0 :             retval = _equalGroupByOrdering(a, b);
     797           0 :             break;
     798           0 :         case T_RestrictInfo:
     799           0 :             retval = _equalRestrictInfo(a, b);
     800           0 :             break;
     801        1228 :         case T_PlaceHolderVar:
     802        1228 :             retval = _equalPlaceHolderVar(a, b);
     803        1228 :             break;
     804           0 :         case T_SpecialJoinInfo:
     805           0 :             retval = _equalSpecialJoinInfo(a, b);
     806           0 :             break;
     807           0 :         case T_AppendRelInfo:
     808           0 :             retval = _equalAppendRelInfo(a, b);
     809           0 :             break;
     810           0 :         case T_PlaceHolderInfo:
     811           0 :             retval = _equalPlaceHolderInfo(a, b);
     812           0 :             break;
     813       36576 :         case T_Bitmapset:
     814       36576 :             retval = _equalBitmapset(a, b);
     815       36576 :             break;
     816           0 :         case T_ExtensibleNode:
     817           0 :             retval = _equalExtensibleNode(a, b);
     818           0 :             break;
     819      956104 :         case T_Integer:
     820      956104 :             retval = _equalInteger(a, b);
     821      956104 :             break;
     822       23028 :         case T_Float:
     823       23028 :             retval = _equalFloat(a, b);
     824       23028 :             break;
     825      162908 :         case T_Boolean:
     826      162908 :             retval = _equalBoolean(a, b);
     827      162908 :             break;
     828    26178978 :         case T_String:
     829    26178978 :             retval = _equalString(a, b);
     830    26178978 :             break;
     831        8136 :         case T_BitString:
     832        8136 :             retval = _equalBitString(a, b);
     833        8136 :             break;

Generated by: LCOV version 1.14