LCOV - code coverage report
Current view: top level - src/backend/nodes - queryjumblefuncs.switch.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 693 747 92.8 %
Date: 2023-11-29 05:10:53 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * queryjumblefuncs.switch.c
       4             :  *    Generated node infrastructure code
       5             :  *
       6             :  * Portions Copyright (c) 1996-2023, 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         458 :             case T_Alias:
      19         458 :                 _jumbleAlias(jstate, expr);
      20         458 :                 break;
      21       28894 :             case T_RangeVar:
      22       28894 :                 _jumbleRangeVar(jstate, expr);
      23       28894 :                 break;
      24          74 :             case T_TableFunc:
      25          74 :                 _jumbleTableFunc(jstate, expr);
      26          74 :                 break;
      27         562 :             case T_IntoClause:
      28         562 :                 _jumbleIntoClause(jstate, expr);
      29         562 :                 break;
      30      295702 :             case T_Var:
      31      295702 :                 _jumbleVar(jstate, expr);
      32      295702 :                 break;
      33      179114 :             case T_Const:
      34      179114 :                 _jumbleConst(jstate, expr);
      35      179114 :                 break;
      36       10042 :             case T_Param:
      37       10042 :                 _jumbleParam(jstate, expr);
      38       10042 :                 break;
      39       12696 :             case T_Aggref:
      40       12696 :                 _jumbleAggref(jstate, expr);
      41       12696 :                 break;
      42         128 :             case T_GroupingFunc:
      43         128 :                 _jumbleGroupingFunc(jstate, expr);
      44         128 :                 break;
      45        1156 :             case T_WindowFunc:
      46        1156 :                 _jumbleWindowFunc(jstate, expr);
      47        1156 :                 break;
      48        2530 :             case T_SubscriptingRef:
      49        2530 :                 _jumbleSubscriptingRef(jstate, expr);
      50        2530 :                 break;
      51       61716 :             case T_FuncExpr:
      52       61716 :                 _jumbleFuncExpr(jstate, expr);
      53       61716 :                 break;
      54         378 :             case T_NamedArgExpr:
      55         378 :                 _jumbleNamedArgExpr(jstate, expr);
      56         378 :                 break;
      57       89248 :             case T_OpExpr:
      58       89248 :                 _jumbleOpExpr(jstate, expr);
      59       89248 :                 break;
      60         110 :             case T_DistinctExpr:
      61         110 :                 _jumbleDistinctExpr(jstate, expr);
      62         110 :                 break;
      63          40 :             case T_NullIfExpr:
      64          40 :                 _jumbleNullIfExpr(jstate, expr);
      65          40 :                 break;
      66        5798 :             case T_ScalarArrayOpExpr:
      67        5798 :                 _jumbleScalarArrayOpExpr(jstate, expr);
      68        5798 :                 break;
      69       21578 :             case T_BoolExpr:
      70       21578 :                 _jumbleBoolExpr(jstate, expr);
      71       21578 :                 break;
      72        7548 :             case T_SubLink:
      73        7548 :                 _jumbleSubLink(jstate, expr);
      74        7548 :                 break;
      75         688 :             case T_FieldSelect:
      76         688 :                 _jumbleFieldSelect(jstate, expr);
      77         688 :                 break;
      78         120 :             case T_FieldStore:
      79         120 :                 _jumbleFieldStore(jstate, expr);
      80         120 :                 break;
      81       15530 :             case T_RelabelType:
      82       15530 :                 _jumbleRelabelType(jstate, expr);
      83       15530 :                 break;
      84        4502 :             case T_CoerceViaIO:
      85        4502 :                 _jumbleCoerceViaIO(jstate, expr);
      86        4502 :                 break;
      87        1140 :             case T_ArrayCoerceExpr:
      88        1140 :                 _jumbleArrayCoerceExpr(jstate, expr);
      89        1140 :                 break;
      90          28 :             case T_ConvertRowtypeExpr:
      91          28 :                 _jumbleConvertRowtypeExpr(jstate, expr);
      92          28 :                 break;
      93        2190 :             case T_CollateExpr:
      94        2190 :                 _jumbleCollateExpr(jstate, expr);
      95        2190 :                 break;
      96        5338 :             case T_CaseExpr:
      97        5338 :                 _jumbleCaseExpr(jstate, expr);
      98        5338 :                 break;
      99        8668 :             case T_CaseWhen:
     100        8668 :                 _jumbleCaseWhen(jstate, expr);
     101        8668 :                 break;
     102        5590 :             case T_CaseTestExpr:
     103        5590 :                 _jumbleCaseTestExpr(jstate, expr);
     104        5590 :                 break;
     105        4302 :             case T_ArrayExpr:
     106        4302 :                 _jumbleArrayExpr(jstate, expr);
     107        4302 :                 break;
     108        1086 :             case T_RowExpr:
     109        1086 :                 _jumbleRowExpr(jstate, expr);
     110        1086 :                 break;
     111          68 :             case T_RowCompareExpr:
     112          68 :                 _jumbleRowCompareExpr(jstate, expr);
     113          68 :                 break;
     114         388 :             case T_CoalesceExpr:
     115         388 :                 _jumbleCoalesceExpr(jstate, expr);
     116         388 :                 break;
     117          76 :             case T_MinMaxExpr:
     118          76 :                 _jumbleMinMaxExpr(jstate, expr);
     119          76 :                 break;
     120         382 :             case T_SQLValueFunction:
     121         382 :                 _jumbleSQLValueFunction(jstate, expr);
     122         382 :                 break;
     123         262 :             case T_XmlExpr:
     124         262 :                 _jumbleXmlExpr(jstate, expr);
     125         262 :                 break;
     126         564 :             case T_JsonFormat:
     127         564 :                 _jumbleJsonFormat(jstate, expr);
     128         564 :                 break;
     129         410 :             case T_JsonReturning:
     130         410 :                 _jumbleJsonReturning(jstate, expr);
     131         410 :                 break;
     132         144 :             case T_JsonValueExpr:
     133         144 :                 _jumbleJsonValueExpr(jstate, expr);
     134         144 :                 break;
     135         400 :             case T_JsonConstructorExpr:
     136         400 :                 _jumbleJsonConstructorExpr(jstate, expr);
     137         400 :                 break;
     138         118 :             case T_JsonIsPredicate:
     139         118 :                 _jumbleJsonIsPredicate(jstate, expr);
     140         118 :                 break;
     141        3234 :             case T_NullTest:
     142        3234 :                 _jumbleNullTest(jstate, expr);
     143        3234 :                 break;
     144         140 :             case T_BooleanTest:
     145         140 :                 _jumbleBooleanTest(jstate, expr);
     146         140 :                 break;
     147         460 :             case T_MergeAction:
     148         460 :                 _jumbleMergeAction(jstate, expr);
     149         460 :                 break;
     150         528 :             case T_CoerceToDomain:
     151         528 :                 _jumbleCoerceToDomain(jstate, expr);
     152         528 :                 break;
     153           0 :             case T_CoerceToDomainValue:
     154           0 :                 _jumbleCoerceToDomainValue(jstate, expr);
     155           0 :                 break;
     156         392 :             case T_SetToDefault:
     157         392 :                 _jumbleSetToDefault(jstate, expr);
     158         392 :                 break;
     159          86 :             case T_CurrentOfExpr:
     160          86 :                 _jumbleCurrentOfExpr(jstate, expr);
     161          86 :                 break;
     162           0 :             case T_NextValueExpr:
     163           0 :                 _jumbleNextValueExpr(jstate, expr);
     164           0 :                 break;
     165         568 :             case T_InferenceElem:
     166         568 :                 _jumbleInferenceElem(jstate, expr);
     167         568 :                 break;
     168      244684 :             case T_TargetEntry:
     169      244684 :                 _jumbleTargetEntry(jstate, expr);
     170      244684 :                 break;
     171       86476 :             case T_RangeTblRef:
     172       86476 :                 _jumbleRangeTblRef(jstate, expr);
     173       86476 :                 break;
     174       12650 :             case T_JoinExpr:
     175       12650 :                 _jumbleJoinExpr(jstate, expr);
     176       12650 :                 break;
     177       97560 :             case T_FromExpr:
     178       97560 :                 _jumbleFromExpr(jstate, expr);
     179       97560 :                 break;
     180         460 :             case T_OnConflictExpr:
     181         460 :                 _jumbleOnConflictExpr(jstate, expr);
     182         460 :                 break;
     183      148098 :             case T_Query:
     184      148098 :                 _jumbleQuery(jstate, expr);
     185      148098 :                 break;
     186       23260 :             case T_TypeName:
     187       23260 :                 _jumbleTypeName(jstate, expr);
     188       23260 :                 break;
     189        6194 :             case T_ColumnRef:
     190        6194 :                 _jumbleColumnRef(jstate, expr);
     191        6194 :                 break;
     192         186 :             case T_ParamRef:
     193         186 :                 _jumbleParamRef(jstate, expr);
     194         186 :                 break;
     195        2516 :             case T_A_Expr:
     196        2516 :                 _jumbleA_Expr(jstate, expr);
     197        2516 :                 break;
     198       14638 :             case T_A_Const:
     199       14638 :                 _jumbleA_Const(jstate, expr);
     200       14638 :                 break;
     201         396 :             case T_TypeCast:
     202         396 :                 _jumbleTypeCast(jstate, expr);
     203         396 :                 break;
     204          84 :             case T_CollateClause:
     205          84 :                 _jumbleCollateClause(jstate, expr);
     206          84 :                 break;
     207        2486 :             case T_RoleSpec:
     208        2486 :                 _jumbleRoleSpec(jstate, expr);
     209        2486 :                 break;
     210         934 :             case T_FuncCall:
     211         934 :                 _jumbleFuncCall(jstate, expr);
     212         934 :                 break;
     213         782 :             case T_A_Star:
     214         782 :                 _jumbleA_Star(jstate, expr);
     215         782 :                 break;
     216          52 :             case T_A_Indices:
     217          52 :                 _jumbleA_Indices(jstate, expr);
     218          52 :                 break;
     219          66 :             case T_A_Indirection:
     220          66 :                 _jumbleA_Indirection(jstate, expr);
     221          66 :                 break;
     222          32 :             case T_A_ArrayExpr:
     223          32 :                 _jumbleA_ArrayExpr(jstate, expr);
     224          32 :                 break;
     225        2926 :             case T_ResTarget:
     226        2926 :                 _jumbleResTarget(jstate, expr);
     227        2926 :                 break;
     228           6 :             case T_MultiAssignRef:
     229           6 :                 _jumbleMultiAssignRef(jstate, expr);
     230           6 :                 break;
     231         132 :             case T_SortBy:
     232         132 :                 _jumbleSortBy(jstate, expr);
     233         132 :                 break;
     234          26 :             case T_WindowDef:
     235          26 :                 _jumbleWindowDef(jstate, expr);
     236          26 :                 break;
     237          90 :             case T_RangeSubselect:
     238          90 :                 _jumbleRangeSubselect(jstate, expr);
     239          90 :                 break;
     240         184 :             case T_RangeFunction:
     241         184 :                 _jumbleRangeFunction(jstate, expr);
     242         184 :                 break;
     243           6 :             case T_RangeTableFunc:
     244           6 :                 _jumbleRangeTableFunc(jstate, expr);
     245           6 :                 break;
     246          34 :             case T_RangeTableFuncCol:
     247          34 :                 _jumbleRangeTableFuncCol(jstate, expr);
     248          34 :                 break;
     249           4 :             case T_RangeTableSample:
     250           4 :                 _jumbleRangeTableSample(jstate, expr);
     251           4 :                 break;
     252       12618 :             case T_ColumnDef:
     253       12618 :                 _jumbleColumnDef(jstate, expr);
     254       12618 :                 break;
     255         206 :             case T_TableLikeClause:
     256         206 :                 _jumbleTableLikeClause(jstate, expr);
     257         206 :                 break;
     258        1968 :             case T_IndexElem:
     259        1968 :                 _jumbleIndexElem(jstate, expr);
     260        1968 :                 break;
     261       15082 :             case T_DefElem:
     262       15082 :                 _jumbleDefElem(jstate, expr);
     263       15082 :                 break;
     264          10 :             case T_LockingClause:
     265          10 :                 _jumbleLockingClause(jstate, expr);
     266          10 :                 break;
     267           4 :             case T_XmlSerialize:
     268           4 :                 _jumbleXmlSerialize(jstate, expr);
     269           4 :                 break;
     270        1276 :             case T_PartitionElem:
     271        1276 :                 _jumblePartitionElem(jstate, expr);
     272        1276 :                 break;
     273        1136 :             case T_PartitionSpec:
     274        1136 :                 _jumblePartitionSpec(jstate, expr);
     275        1136 :                 break;
     276        2430 :             case T_PartitionBoundSpec:
     277        2430 :                 _jumblePartitionBoundSpec(jstate, expr);
     278        2430 :                 break;
     279           0 :             case T_PartitionRangeDatum:
     280           0 :                 _jumblePartitionRangeDatum(jstate, expr);
     281           0 :                 break;
     282         722 :             case T_PartitionCmd:
     283         722 :                 _jumblePartitionCmd(jstate, expr);
     284         722 :                 break;
     285      108840 :             case T_RangeTblEntry:
     286      108840 :                 _jumbleRangeTblEntry(jstate, expr);
     287      108840 :                 break;
     288           0 :             case T_RTEPermissionInfo:
     289           0 :                 _jumbleRTEPermissionInfo(jstate, expr);
     290           0 :                 break;
     291        6084 :             case T_RangeTblFunction:
     292        6084 :                 _jumbleRangeTblFunction(jstate, expr);
     293        6084 :                 break;
     294          68 :             case T_TableSampleClause:
     295          68 :                 _jumbleTableSampleClause(jstate, expr);
     296          68 :                 break;
     297           0 :             case T_WithCheckOption:
     298           0 :                 _jumbleWithCheckOption(jstate, expr);
     299           0 :                 break;
     300       25356 :             case T_SortGroupClause:
     301       25356 :                 _jumbleSortGroupClause(jstate, expr);
     302       25356 :                 break;
     303        1056 :             case T_GroupingSet:
     304        1056 :                 _jumbleGroupingSet(jstate, expr);
     305        1056 :                 break;
     306         950 :             case T_WindowClause:
     307         950 :                 _jumbleWindowClause(jstate, expr);
     308         950 :                 break;
     309         528 :             case T_RowMarkClause:
     310         528 :                 _jumbleRowMarkClause(jstate, expr);
     311         528 :                 break;
     312          30 :             case T_WithClause:
     313          30 :                 _jumbleWithClause(jstate, expr);
     314          30 :                 break;
     315           4 :             case T_InferClause:
     316           4 :                 _jumbleInferClause(jstate, expr);
     317           4 :                 break;
     318           6 :             case T_OnConflictClause:
     319           6 :                 _jumbleOnConflictClause(jstate, expr);
     320           6 :                 break;
     321           0 :             case T_CTESearchClause:
     322           0 :                 _jumbleCTESearchClause(jstate, expr);
     323           0 :                 break;
     324           0 :             case T_CTECycleClause:
     325           0 :                 _jumbleCTECycleClause(jstate, expr);
     326           0 :                 break;
     327         708 :             case T_CommonTableExpr:
     328         708 :                 _jumbleCommonTableExpr(jstate, expr);
     329         708 :                 break;
     330          26 :             case T_MergeWhenClause:
     331          26 :                 _jumbleMergeWhenClause(jstate, expr);
     332          26 :                 break;
     333         176 :             case T_TriggerTransition:
     334         176 :                 _jumbleTriggerTransition(jstate, expr);
     335         176 :                 break;
     336          10 :             case T_JsonOutput:
     337          10 :                 _jumbleJsonOutput(jstate, expr);
     338          10 :                 break;
     339           6 :             case T_JsonKeyValue:
     340           6 :                 _jumbleJsonKeyValue(jstate, expr);
     341           6 :                 break;
     342           0 :             case T_JsonParseExpr:
     343           0 :                 _jumbleJsonParseExpr(jstate, expr);
     344           0 :                 break;
     345           0 :             case T_JsonScalarExpr:
     346           0 :                 _jumbleJsonScalarExpr(jstate, expr);
     347           0 :                 break;
     348           0 :             case T_JsonSerializeExpr:
     349           0 :                 _jumbleJsonSerializeExpr(jstate, expr);
     350           0 :                 break;
     351           2 :             case T_JsonObjectConstructor:
     352           2 :                 _jumbleJsonObjectConstructor(jstate, expr);
     353           2 :                 break;
     354           2 :             case T_JsonArrayConstructor:
     355           2 :                 _jumbleJsonArrayConstructor(jstate, expr);
     356           2 :                 break;
     357           2 :             case T_JsonArrayQueryConstructor:
     358           2 :                 _jumbleJsonArrayQueryConstructor(jstate, expr);
     359           2 :                 break;
     360           4 :             case T_JsonAggConstructor:
     361           4 :                 _jumbleJsonAggConstructor(jstate, expr);
     362           4 :                 break;
     363           2 :             case T_JsonObjectAgg:
     364           2 :                 _jumbleJsonObjectAgg(jstate, expr);
     365           2 :                 break;
     366           2 :             case T_JsonArrayAgg:
     367           2 :                 _jumbleJsonArrayAgg(jstate, expr);
     368           2 :                 break;
     369         160 :             case T_InsertStmt:
     370         160 :                 _jumbleInsertStmt(jstate, expr);
     371         160 :                 break;
     372          62 :             case T_DeleteStmt:
     373          62 :                 _jumbleDeleteStmt(jstate, expr);
     374          62 :                 break;
     375          84 :             case T_UpdateStmt:
     376          84 :                 _jumbleUpdateStmt(jstate, expr);
     377          84 :                 break;
     378           8 :             case T_MergeStmt:
     379           8 :                 _jumbleMergeStmt(jstate, expr);
     380           8 :                 break;
     381        1730 :             case T_SelectStmt:
     382        1730 :                 _jumbleSelectStmt(jstate, expr);
     383        1730 :                 break;
     384        2846 :             case T_SetOperationStmt:
     385        2846 :                 _jumbleSetOperationStmt(jstate, expr);
     386        2846 :                 break;
     387          26 :             case T_ReturnStmt:
     388          26 :                 _jumbleReturnStmt(jstate, expr);
     389          26 :                 break;
     390           0 :             case T_PLAssignStmt:
     391           0 :                 _jumblePLAssignStmt(jstate, expr);
     392           0 :                 break;
     393         204 :             case T_CreateSchemaStmt:
     394         204 :                 _jumbleCreateSchemaStmt(jstate, expr);
     395         204 :                 break;
     396        3768 :             case T_AlterTableStmt:
     397        3768 :                 _jumbleAlterTableStmt(jstate, expr);
     398        3768 :                 break;
     399          96 :             case T_ReplicaIdentityStmt:
     400          96 :                 _jumbleReplicaIdentityStmt(jstate, expr);
     401          96 :                 break;
     402        4036 :             case T_AlterTableCmd:
     403        4036 :                 _jumbleAlterTableCmd(jstate, expr);
     404        4036 :                 break;
     405           0 :             case T_AlterCollationStmt:
     406           0 :                 _jumbleAlterCollationStmt(jstate, expr);
     407           0 :                 break;
     408          82 :             case T_AlterDomainStmt:
     409          82 :                 _jumbleAlterDomainStmt(jstate, expr);
     410          82 :                 break;
     411         838 :             case T_GrantStmt:
     412         838 :                 _jumbleGrantStmt(jstate, expr);
     413         838 :                 break;
     414        1400 :             case T_ObjectWithArgs:
     415        1400 :                 _jumbleObjectWithArgs(jstate, expr);
     416        1400 :                 break;
     417         858 :             case T_AccessPriv:
     418         858 :                 _jumbleAccessPriv(jstate, expr);
     419         858 :                 break;
     420         192 :             case T_GrantRoleStmt:
     421         192 :                 _jumbleGrantRoleStmt(jstate, expr);
     422         192 :                 break;
     423          50 :             case T_AlterDefaultPrivilegesStmt:
     424          50 :                 _jumbleAlterDefaultPrivilegesStmt(jstate, expr);
     425          50 :                 break;
     426        2872 :             case T_CopyStmt:
     427        2872 :                 _jumbleCopyStmt(jstate, expr);
     428        2872 :                 break;
     429        4344 :             case T_VariableSetStmt:
     430        4344 :                 _jumbleVariableSetStmt(jstate, expr);
     431        4344 :                 break;
     432         234 :             case T_VariableShowStmt:
     433         234 :                 _jumbleVariableShowStmt(jstate, expr);
     434         234 :                 break;
     435        7000 :             case T_CreateStmt:
     436        7000 :                 _jumbleCreateStmt(jstate, expr);
     437        7000 :                 break;
     438        3428 :             case T_Constraint:
     439        3428 :                 _jumbleConstraint(jstate, expr);
     440        3428 :                 break;
     441          12 :             case T_CreateTableSpaceStmt:
     442          12 :                 _jumbleCreateTableSpaceStmt(jstate, expr);
     443          12 :                 break;
     444           8 :             case T_DropTableSpaceStmt:
     445           8 :                 _jumbleDropTableSpaceStmt(jstate, expr);
     446           8 :                 break;
     447           8 :             case T_AlterTableSpaceOptionsStmt:
     448           8 :                 _jumbleAlterTableSpaceOptionsStmt(jstate, expr);
     449           8 :                 break;
     450          10 :             case T_AlterTableMoveAllStmt:
     451          10 :                 _jumbleAlterTableMoveAllStmt(jstate, expr);
     452          10 :                 break;
     453           6 :             case T_CreateExtensionStmt:
     454           6 :                 _jumbleCreateExtensionStmt(jstate, expr);
     455           6 :                 break;
     456          14 :             case T_AlterExtensionStmt:
     457          14 :                 _jumbleAlterExtensionStmt(jstate, expr);
     458          14 :                 break;
     459          42 :             case T_AlterExtensionContentsStmt:
     460          42 :                 _jumbleAlterExtensionContentsStmt(jstate, expr);
     461          42 :                 break;
     462          50 :             case T_CreateFdwStmt:
     463          50 :                 _jumbleCreateFdwStmt(jstate, expr);
     464          50 :                 break;
     465          38 :             case T_AlterFdwStmt:
     466          38 :                 _jumbleAlterFdwStmt(jstate, expr);
     467          38 :                 break;
     468          64 :             case T_CreateForeignServerStmt:
     469          64 :                 _jumbleCreateForeignServerStmt(jstate, expr);
     470          64 :                 break;
     471          26 :             case T_AlterForeignServerStmt:
     472          26 :                 _jumbleAlterForeignServerStmt(jstate, expr);
     473          26 :                 break;
     474          56 :             case T_CreateForeignTableStmt:
     475          56 :                 _jumbleCreateForeignTableStmt(jstate, expr);
     476          56 :                 break;
     477          54 :             case T_CreateUserMappingStmt:
     478          54 :                 _jumbleCreateUserMappingStmt(jstate, expr);
     479          54 :                 break;
     480          22 :             case T_AlterUserMappingStmt:
     481          22 :                 _jumbleAlterUserMappingStmt(jstate, expr);
     482          22 :                 break;
     483          24 :             case T_DropUserMappingStmt:
     484          24 :                 _jumbleDropUserMappingStmt(jstate, expr);
     485          24 :                 break;
     486           8 :             case T_ImportForeignSchemaStmt:
     487           8 :                 _jumbleImportForeignSchemaStmt(jstate, expr);
     488           8 :                 break;
     489         204 :             case T_CreatePolicyStmt:
     490         204 :                 _jumbleCreatePolicyStmt(jstate, expr);
     491         204 :                 break;
     492          28 :             case T_AlterPolicyStmt:
     493          28 :                 _jumbleAlterPolicyStmt(jstate, expr);
     494          28 :                 break;
     495          14 :             case T_CreateAmStmt:
     496          14 :                 _jumbleCreateAmStmt(jstate, expr);
     497          14 :                 break;
     498         724 :             case T_CreateTrigStmt:
     499         724 :                 _jumbleCreateTrigStmt(jstate, expr);
     500         724 :                 break;
     501          50 :             case T_CreateEventTrigStmt:
     502          50 :                 _jumbleCreateEventTrigStmt(jstate, expr);
     503          50 :                 break;
     504          12 :             case T_AlterEventTrigStmt:
     505          12 :                 _jumbleAlterEventTrigStmt(jstate, expr);
     506          12 :                 break;
     507           4 :             case T_CreatePLangStmt:
     508           4 :                 _jumbleCreatePLangStmt(jstate, expr);
     509           4 :                 break;
     510         422 :             case T_CreateRoleStmt:
     511         422 :                 _jumbleCreateRoleStmt(jstate, expr);
     512         422 :                 break;
     513          94 :             case T_AlterRoleStmt:
     514          94 :                 _jumbleAlterRoleStmt(jstate, expr);
     515          94 :                 break;
     516           2 :             case T_AlterRoleSetStmt:
     517           2 :                 _jumbleAlterRoleSetStmt(jstate, expr);
     518           2 :                 break;
     519         484 :             case T_DropRoleStmt:
     520         484 :                 _jumbleDropRoleStmt(jstate, expr);
     521         484 :                 break;
     522         150 :             case T_CreateSeqStmt:
     523         150 :                 _jumbleCreateSeqStmt(jstate, expr);
     524         150 :                 break;
     525          50 :             case T_AlterSeqStmt:
     526          50 :                 _jumbleAlterSeqStmt(jstate, expr);
     527          50 :                 break;
     528         546 :             case T_DefineStmt:
     529         546 :                 _jumbleDefineStmt(jstate, expr);
     530         546 :                 break;
     531         186 :             case T_CreateDomainStmt:
     532         186 :                 _jumbleCreateDomainStmt(jstate, expr);
     533         186 :                 break;
     534          28 :             case T_CreateOpClassStmt:
     535          28 :                 _jumbleCreateOpClassStmt(jstate, expr);
     536          28 :                 break;
     537         244 :             case T_CreateOpClassItem:
     538         244 :                 _jumbleCreateOpClassItem(jstate, expr);
     539         244 :                 break;
     540          42 :             case T_CreateOpFamilyStmt:
     541          42 :                 _jumbleCreateOpFamilyStmt(jstate, expr);
     542          42 :                 break;
     543          88 :             case T_AlterOpFamilyStmt:
     544          88 :                 _jumbleAlterOpFamilyStmt(jstate, expr);
     545          88 :                 break;
     546        5174 :             case T_DropStmt:
     547        5174 :                 _jumbleDropStmt(jstate, expr);
     548        5174 :                 break;
     549         296 :             case T_TruncateStmt:
     550         296 :                 _jumbleTruncateStmt(jstate, expr);
     551         296 :                 break;
     552         214 :             case T_CommentStmt:
     553         214 :                 _jumbleCommentStmt(jstate, expr);
     554         214 :                 break;
     555          16 :             case T_SecLabelStmt:
     556          16 :                 _jumbleSecLabelStmt(jstate, expr);
     557          16 :                 break;
     558         274 :             case T_DeclareCursorStmt:
     559         274 :                 _jumbleDeclareCursorStmt(jstate, expr);
     560         274 :                 break;
     561          96 :             case T_ClosePortalStmt:
     562          96 :                 _jumbleClosePortalStmt(jstate, expr);
     563          96 :                 break;
     564         558 :             case T_FetchStmt:
     565         558 :                 _jumbleFetchStmt(jstate, expr);
     566         558 :                 break;
     567        1322 :             case T_IndexStmt:
     568        1322 :                 _jumbleIndexStmt(jstate, expr);
     569        1322 :                 break;
     570         178 :             case T_CreateStatsStmt:
     571         178 :                 _jumbleCreateStatsStmt(jstate, expr);
     572         178 :                 break;
     573         468 :             case T_StatsElem:
     574         468 :                 _jumbleStatsElem(jstate, expr);
     575         468 :                 break;
     576           8 :             case T_AlterStatsStmt:
     577           8 :                 _jumbleAlterStatsStmt(jstate, expr);
     578           8 :                 break;
     579        1878 :             case T_CreateFunctionStmt:
     580        1878 :                 _jumbleCreateFunctionStmt(jstate, expr);
     581        1878 :                 break;
     582        4234 :             case T_FunctionParameter:
     583        4234 :                 _jumbleFunctionParameter(jstate, expr);
     584        4234 :                 break;
     585          48 :             case T_AlterFunctionStmt:
     586          48 :                 _jumbleAlterFunctionStmt(jstate, expr);
     587          48 :                 break;
     588         150 :             case T_DoStmt:
     589         150 :                 _jumbleDoStmt(jstate, expr);
     590         150 :                 break;
     591          82 :             case T_CallStmt:
     592          82 :                 _jumbleCallStmt(jstate, expr);
     593          82 :                 break;
     594         396 :             case T_RenameStmt:
     595         396 :                 _jumbleRenameStmt(jstate, expr);
     596         396 :                 break;
     597           0 :             case T_AlterObjectDependsStmt:
     598           0 :                 _jumbleAlterObjectDependsStmt(jstate, expr);
     599           0 :                 break;
     600         120 :             case T_AlterObjectSchemaStmt:
     601         120 :                 _jumbleAlterObjectSchemaStmt(jstate, expr);
     602         120 :                 break;
     603         168 :             case T_AlterOwnerStmt:
     604         168 :                 _jumbleAlterOwnerStmt(jstate, expr);
     605         168 :                 break;
     606          54 :             case T_AlterOperatorStmt:
     607          54 :                 _jumbleAlterOperatorStmt(jstate, expr);
     608          54 :                 break;
     609           8 :             case T_AlterTypeStmt:
     610           8 :                 _jumbleAlterTypeStmt(jstate, expr);
     611           8 :                 break;
     612         258 :             case T_RuleStmt:
     613         258 :                 _jumbleRuleStmt(jstate, expr);
     614         258 :                 break;
     615          12 :             case T_NotifyStmt:
     616          12 :                 _jumbleNotifyStmt(jstate, expr);
     617          12 :                 break;
     618           4 :             case T_ListenStmt:
     619           4 :                 _jumbleListenStmt(jstate, expr);
     620           4 :                 break;
     621           4 :             case T_UnlistenStmt:
     622           4 :                 _jumbleUnlistenStmt(jstate, expr);
     623           4 :                 break;
     624        3164 :             case T_TransactionStmt:
     625        3164 :                 _jumbleTransactionStmt(jstate, expr);
     626        3164 :                 break;
     627         164 :             case T_CompositeTypeStmt:
     628         164 :                 _jumbleCompositeTypeStmt(jstate, expr);
     629         164 :                 break;
     630          40 :             case T_CreateEnumStmt:
     631          40 :                 _jumbleCreateEnumStmt(jstate, expr);
     632          40 :                 break;
     633          38 :             case T_CreateRangeStmt:
     634          38 :                 _jumbleCreateRangeStmt(jstate, expr);
     635          38 :                 break;
     636          96 :             case T_AlterEnumStmt:
     637          96 :                 _jumbleAlterEnumStmt(jstate, expr);
     638          96 :                 break;
     639         862 :             case T_ViewStmt:
     640         862 :                 _jumbleViewStmt(jstate, expr);
     641         862 :                 break;
     642           4 :             case T_LoadStmt:
     643           4 :                 _jumbleLoadStmt(jstate, expr);
     644           4 :                 break;
     645           6 :             case T_CreatedbStmt:
     646           6 :                 _jumbleCreatedbStmt(jstate, expr);
     647           6 :                 break;
     648           0 :             case T_AlterDatabaseStmt:
     649           0 :                 _jumbleAlterDatabaseStmt(jstate, expr);
     650           0 :                 break;
     651           0 :             case T_AlterDatabaseRefreshCollStmt:
     652           0 :                 _jumbleAlterDatabaseRefreshCollStmt(jstate, expr);
     653           0 :                 break;
     654          24 :             case T_AlterDatabaseSetStmt:
     655          24 :                 _jumbleAlterDatabaseSetStmt(jstate, expr);
     656          24 :                 break;
     657          10 :             case T_DropdbStmt:
     658          10 :                 _jumbleDropdbStmt(jstate, expr);
     659          10 :                 break;
     660           0 :             case T_AlterSystemStmt:
     661           0 :                 _jumbleAlterSystemStmt(jstate, expr);
     662           0 :                 break;
     663          50 :             case T_ClusterStmt:
     664          50 :                 _jumbleClusterStmt(jstate, expr);
     665          50 :                 break;
     666         880 :             case T_VacuumStmt:
     667         880 :                 _jumbleVacuumStmt(jstate, expr);
     668         880 :                 break;
     669         914 :             case T_VacuumRelation:
     670         914 :                 _jumbleVacuumRelation(jstate, expr);
     671         914 :                 break;
     672        5992 :             case T_ExplainStmt:
     673        5992 :                 _jumbleExplainStmt(jstate, expr);
     674        5992 :                 break;
     675         556 :             case T_CreateTableAsStmt:
     676         556 :                 _jumbleCreateTableAsStmt(jstate, expr);
     677         556 :                 break;
     678          70 :             case T_RefreshMatViewStmt:
     679          70 :                 _jumbleRefreshMatViewStmt(jstate, expr);
     680          70 :                 break;
     681          12 :             case T_CheckPointStmt:
     682          12 :                 _jumbleCheckPointStmt(jstate, expr);
     683          12 :                 break;
     684           8 :             case T_DiscardStmt:
     685           8 :                 _jumbleDiscardStmt(jstate, expr);
     686           8 :                 break;
     687         118 :             case T_LockStmt:
     688         118 :                 _jumbleLockStmt(jstate, expr);
     689         118 :                 break;
     690          32 :             case T_ConstraintsSetStmt:
     691          32 :                 _jumbleConstraintsSetStmt(jstate, expr);
     692          32 :                 break;
     693         190 :             case T_ReindexStmt:
     694         190 :                 _jumbleReindexStmt(jstate, expr);
     695         190 :                 break;
     696          20 :             case T_CreateConversionStmt:
     697          20 :                 _jumbleCreateConversionStmt(jstate, expr);
     698          20 :                 break;
     699          44 :             case T_CreateCastStmt:
     700          44 :                 _jumbleCreateCastStmt(jstate, expr);
     701          44 :                 break;
     702           2 :             case T_CreateTransformStmt:
     703           2 :                 _jumbleCreateTransformStmt(jstate, expr);
     704           2 :                 break;
     705         200 :             case T_PrepareStmt:
     706         200 :                 _jumblePrepareStmt(jstate, expr);
     707         200 :                 break;
     708        2964 :             case T_ExecuteStmt:
     709        2964 :                 _jumbleExecuteStmt(jstate, expr);
     710        2964 :                 break;
     711          74 :             case T_DeallocateStmt:
     712          74 :                 _jumbleDeallocateStmt(jstate, expr);
     713          74 :                 break;
     714          40 :             case T_DropOwnedStmt:
     715          40 :                 _jumbleDropOwnedStmt(jstate, expr);
     716          40 :                 break;
     717          12 :             case T_ReassignOwnedStmt:
     718          12 :                 _jumbleReassignOwnedStmt(jstate, expr);
     719          12 :                 break;
     720           6 :             case T_AlterTSDictionaryStmt:
     721           6 :                 _jumbleAlterTSDictionaryStmt(jstate, expr);
     722           6 :                 break;
     723          12 :             case T_AlterTSConfigurationStmt:
     724          12 :                 _jumbleAlterTSConfigurationStmt(jstate, expr);
     725          12 :                 break;
     726         324 :             case T_PublicationTable:
     727         324 :                 _jumblePublicationTable(jstate, expr);
     728         324 :                 break;
     729         438 :             case T_PublicationObjSpec:
     730         438 :                 _jumblePublicationObjSpec(jstate, expr);
     731         438 :                 break;
     732         144 :             case T_CreatePublicationStmt:
     733         144 :                 _jumbleCreatePublicationStmt(jstate, expr);
     734         144 :                 break;
     735         312 :             case T_AlterPublicationStmt:
     736         312 :                 _jumbleAlterPublicationStmt(jstate, expr);
     737         312 :                 break;
     738          68 :             case T_CreateSubscriptionStmt:
     739          68 :                 _jumbleCreateSubscriptionStmt(jstate, expr);
     740          68 :                 break;
     741          98 :             case T_AlterSubscriptionStmt:
     742          98 :                 _jumbleAlterSubscriptionStmt(jstate, expr);
     743          98 :                 break;
     744          28 :             case T_DropSubscriptionStmt:
     745          28 :                 _jumbleDropSubscriptionStmt(jstate, expr);
     746          28 :                 break;
     747           0 :             case T_ExtensibleNode:
     748           0 :                 _jumbleExtensibleNode(jstate, expr);
     749           0 :                 break;
     750        1138 :             case T_Integer:
     751        1138 :                 _jumbleInteger(jstate, expr);
     752        1138 :                 break;
     753          34 :             case T_Float:
     754          34 :                 _jumbleFloat(jstate, expr);
     755          34 :                 break;
     756         632 :             case T_Boolean:
     757         632 :                 _jumbleBoolean(jstate, expr);
     758         632 :                 break;
     759       79190 :             case T_String:
     760       79190 :                 _jumbleString(jstate, expr);
     761       79190 :                 break;
     762           0 :             case T_BitString:
     763           0 :                 _jumbleBitString(jstate, expr);
     764           0 :                 break;

Generated by: LCOV version 1.14