Convert eval_const_expressions's long series of IsA tests into a switch.

tglsfdc · tglsfdc · commit a04161f2eab5 · 2011-11-28T14:21:40.000-05:00
This function has now grown enough cases that a switch seems appropriate.
This results in a measurable speed improvement on some platforms, and
should certainly not hurt.  The code's in need of a pgindent run now,
though.

Andres Freund
diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
@@ -2106,7 +2106,9 @@ eval_const_expressions_mutator(Node *node,
 {
 	if (node == NULL)
 		return NULL;
-	if (IsA(node, Param))
+	switch (nodeTag(node))
+	{
+		case T_Param:
 	{
 		Param	   *param = (Param *) node;
 
@@ -2152,7 +2154,7 @@ eval_const_expressions_mutator(Node *node,
 		/* Not replaceable, so just copy the Param (no need to recurse) */
 		return (Node *) copyObject(param);
 	}
-	if (IsA(node, FuncExpr))
+		case T_FuncExpr:
 	{
 		FuncExpr   *expr = (FuncExpr *) node;
 		List	   *args;
@@ -2210,7 +2212,7 @@ eval_const_expressions_mutator(Node *node,
 		newexpr->location = expr->location;
 		return (Node *) newexpr;
 	}
-	if (IsA(node, OpExpr))
+		case T_OpExpr:
 	{
 		OpExpr	   *expr = (OpExpr *) node;
 		List	   *args;
@@ -2275,7 +2277,7 @@ eval_const_expressions_mutator(Node *node,
 		newexpr->location = expr->location;
 		return (Node *) newexpr;
 	}
-	if (IsA(node, DistinctExpr))
+		case T_DistinctExpr:
 	{
 		DistinctExpr *expr = (DistinctExpr *) node;
 		List	   *args;
@@ -2372,7 +2374,7 @@ eval_const_expressions_mutator(Node *node,
 		newexpr->location = expr->location;
 		return (Node *) newexpr;
 	}
-	if (IsA(node, BoolExpr))
+		case T_BoolExpr:
 	{
 		BoolExpr   *expr = (BoolExpr *) node;
 
@@ -2439,19 +2441,18 @@ eval_const_expressions_mutator(Node *node,
 					 (int) expr->boolop);
 				break;
 		}
+		break;
 	}
-	if (IsA(node, SubPlan) ||
-		IsA(node, AlternativeSubPlan))
-	{
+		case T_SubPlan:
+		case T_AlternativeSubPlan:
 		/*
 		 * Return a SubPlan unchanged --- too late to do anything with it.
 		 *
 		 * XXX should we ereport() here instead?  Probably this routine should
 		 * never be invoked after SubPlan creation.
 		 */
 		return node;
-	}
-	if (IsA(node, RelabelType))
+		case T_RelabelType:
 	{
 		/*
 		 * If we can simplify the input to a constant, then we don't need the
@@ -2493,7 +2494,7 @@ eval_const_expressions_mutator(Node *node,
 			return (Node *) newrelabel;
 		}
 	}
-	if (IsA(node, CoerceViaIO))
+		case T_CoerceViaIO:
 	{
 		CoerceViaIO *expr = (CoerceViaIO *) node;
 		Expr	   *arg;
@@ -2569,7 +2570,7 @@ eval_const_expressions_mutator(Node *node,
 		newexpr->location = expr->location;
 		return (Node *) newexpr;
 	}
-	if (IsA(node, ArrayCoerceExpr))
+		case T_ArrayCoerceExpr:
 	{
 		ArrayCoerceExpr *expr = (ArrayCoerceExpr *) node;
 		Expr	   *arg;
@@ -2607,7 +2608,7 @@ eval_const_expressions_mutator(Node *node,
 		/* Else we must return the partially-simplified node */
 		return (Node *) newexpr;
 	}
-	if (IsA(node, CollateExpr))
+	case T_CollateExpr:
 	{
 		/*
 		 * If we can simplify the input to a constant, then we don't need the
@@ -2652,7 +2653,7 @@ eval_const_expressions_mutator(Node *node,
 			return (Node *) relabel;
 		}
 	}
-	if (IsA(node, CaseExpr))
+	case T_CaseExpr:
 	{
 		/*----------
 		 * CASE expressions can be simplified if there are constant
@@ -2783,7 +2784,7 @@ eval_const_expressions_mutator(Node *node,
 		newcase->location = caseexpr->location;
 		return (Node *) newcase;
 	}
-	if (IsA(node, CaseTestExpr))
+		case T_CaseTestExpr:
 	{
 		/*
 		 * If we know a constant test value for the current CASE construct,
@@ -2795,7 +2796,7 @@ eval_const_expressions_mutator(Node *node,
 		else
 			return copyObject(node);
 	}
-	if (IsA(node, ArrayExpr))
+		case T_ArrayExpr:
 	{
 		ArrayExpr  *arrayexpr = (ArrayExpr *) node;
 		ArrayExpr  *newarray;
@@ -2831,7 +2832,7 @@ eval_const_expressions_mutator(Node *node,
 
 		return (Node *) newarray;
 	}
-	if (IsA(node, CoalesceExpr))
+		case T_CoalesceExpr:
 	{
 		CoalesceExpr *coalesceexpr = (CoalesceExpr *) node;
 		CoalesceExpr *newcoalesce;
@@ -2878,7 +2879,7 @@ eval_const_expressions_mutator(Node *node,
 		newcoalesce->location = coalesceexpr->location;
 		return (Node *) newcoalesce;
 	}
-	if (IsA(node, FieldSelect))
+		case T_FieldSelect:
 	{
 		/*
 		 * We can optimize field selection from a whole-row Var into a simple
@@ -2941,7 +2942,7 @@ eval_const_expressions_mutator(Node *node,
 		newfselect->resultcollid = fselect->resultcollid;
 		return (Node *) newfselect;
 	}
-	if (IsA(node, NullTest))
+		case T_NullTest:
 	{
 		NullTest   *ntest = (NullTest *) node;
 		NullTest   *newntest;
@@ -3024,7 +3025,7 @@ eval_const_expressions_mutator(Node *node,
 		newntest->argisrow = ntest->argisrow;
 		return (Node *) newntest;
 	}
-	if (IsA(node, BooleanTest))
+		case T_BooleanTest:
 	{
 		BooleanTest *btest = (BooleanTest *) node;
 		BooleanTest *newbtest;
@@ -3076,19 +3077,24 @@ eval_const_expressions_mutator(Node *node,
 		newbtest->booltesttype = btest->booltesttype;
 		return (Node *) newbtest;
 	}
-	if (IsA(node, PlaceHolderVar) &&context->estimate)
-	{
+		case T_PlaceHolderVar:
 		/*
 		 * In estimation mode, just strip the PlaceHolderVar node altogether;
 		 * this amounts to estimating that the contained value won't be forced
 		 * to null by an outer join.  In regular mode we just use the default
 		 * behavior (ie, simplify the expression but leave the PlaceHolderVar
 		 * node intact).
 		 */
-		PlaceHolderVar *phv = (PlaceHolderVar *) node;
+			if (context->estimate)
+			{
+				PlaceHolderVar *phv = (PlaceHolderVar *) node;
 
-		return eval_const_expressions_mutator((Node *) phv->phexpr,
-											  context);
+				return eval_const_expressions_mutator((Node *) phv->phexpr,
+													  context);
+			}
+			break;
+		default:
+			break;
 	}
 
 	/*

Original file line number	Diff line number	Diff line change
`@@ -2106,7 +2106,9 @@ eval_const_expressions_mutator(Node *node,`
`2106`	`2106`	`{`
`2107`	`2107`	`if (node == NULL)`
`2108`	`2108`	`return NULL;`
`2109`		`- if (IsA(node, Param))`
	`2109`	`+ switch (nodeTag(node))`
	`2110`	`+ {`
	`2111`	`+ case T_Param:`
`2110`	`2112`	`{`
`2111`	`2113`	`Param param = (Param ) node;`
`2112`	`2114`
`@@ -2152,7 +2154,7 @@ eval_const_expressions_mutator(Node *node,`
`2152`	`2154`	`/* Not replaceable, so just copy the Param (no need to recurse) */`
`2153`	`2155`	`return (Node *) copyObject(param);`
`2154`	`2156`	`}`
`2155`		`- if (IsA(node, FuncExpr))`
	`2157`	`+ case T_FuncExpr:`
`2156`	`2158`	`{`
`2157`	`2159`	`FuncExpr expr = (FuncExpr ) node;`
`2158`	`2160`	`List *args;`
`@@ -2210,7 +2212,7 @@ eval_const_expressions_mutator(Node *node,`
`2210`	`2212`	`newexpr->location = expr->location;`
`2211`	`2213`	`return (Node *) newexpr;`
`2212`	`2214`	`}`
`2213`		`- if (IsA(node, OpExpr))`
	`2215`	`+ case T_OpExpr:`
`2214`	`2216`	`{`
`2215`	`2217`	`OpExpr expr = (OpExpr ) node;`
`2216`	`2218`	`List *args;`
`@@ -2275,7 +2277,7 @@ eval_const_expressions_mutator(Node *node,`
`2275`	`2277`	`newexpr->location = expr->location;`
`2276`	`2278`	`return (Node *) newexpr;`
`2277`	`2279`	`}`
`2278`		`- if (IsA(node, DistinctExpr))`
	`2280`	`+ case T_DistinctExpr:`
`2279`	`2281`	`{`
`2280`	`2282`	`DistinctExpr expr = (DistinctExpr ) node;`
`2281`	`2283`	`List *args;`
`@@ -2372,7 +2374,7 @@ eval_const_expressions_mutator(Node *node,`
`2372`	`2374`	`newexpr->location = expr->location;`
`2373`	`2375`	`return (Node *) newexpr;`
`2374`	`2376`	`}`
`2375`		`- if (IsA(node, BoolExpr))`
	`2377`	`+ case T_BoolExpr:`
`2376`	`2378`	`{`
`2377`	`2379`	`BoolExpr expr = (BoolExpr ) node;`
`2378`	`2380`
`@@ -2439,19 +2441,18 @@ eval_const_expressions_mutator(Node *node,`
`2439`	`2441`	`(int) expr->boolop);`
`2440`	`2442`	`break;`
`2441`	`2443`	`}`
	`2444`	`+ break;`
`2442`	`2445`	`}`
`2443`		`- if (IsA(node, SubPlan) \|\|`
`2444`		`- IsA(node, AlternativeSubPlan))`
`2445`		`- {`
	`2446`	`+ case T_SubPlan:`
	`2447`	`+ case T_AlternativeSubPlan:`
`2446`	`2448`	`/*`
`2447`	`2449`	`* Return a SubPlan unchanged --- too late to do anything with it.`
`2448`	`2450`	`*`
`2449`	`2451`	`* XXX should we ereport() here instead? Probably this routine should`
`2450`	`2452`	`* never be invoked after SubPlan creation.`
`2451`	`2453`	`*/`
`2452`	`2454`	`return node;`
`2453`		`- }`
`2454`		`- if (IsA(node, RelabelType))`
	`2455`	`+ case T_RelabelType:`
`2455`	`2456`	`{`
`2456`	`2457`	`/*`
`2457`	`2458`	`* If we can simplify the input to a constant, then we don't need the`
`@@ -2493,7 +2494,7 @@ eval_const_expressions_mutator(Node *node,`
`2493`	`2494`	`return (Node *) newrelabel;`
`2494`	`2495`	`}`
`2495`	`2496`	`}`
`2496`		`- if (IsA(node, CoerceViaIO))`
	`2497`	`+ case T_CoerceViaIO:`
`2497`	`2498`	`{`
`2498`	`2499`	`CoerceViaIO expr = (CoerceViaIO ) node;`
`2499`	`2500`	`Expr *arg;`
`@@ -2569,7 +2570,7 @@ eval_const_expressions_mutator(Node *node,`
`2569`	`2570`	`newexpr->location = expr->location;`
`2570`	`2571`	`return (Node *) newexpr;`
`2571`	`2572`	`}`
`2572`		`- if (IsA(node, ArrayCoerceExpr))`
	`2573`	`+ case T_ArrayCoerceExpr:`
`2573`	`2574`	`{`
`2574`	`2575`	`ArrayCoerceExpr expr = (ArrayCoerceExpr ) node;`
`2575`	`2576`	`Expr *arg;`
`@@ -2607,7 +2608,7 @@ eval_const_expressions_mutator(Node *node,`
`2607`	`2608`	`/* Else we must return the partially-simplified node */`
`2608`	`2609`	`return (Node *) newexpr;`
`2609`	`2610`	`}`
`2610`		`- if (IsA(node, CollateExpr))`
	`2611`	`+ case T_CollateExpr:`
`2611`	`2612`	`{`
`2612`	`2613`	`/*`
`2613`	`2614`	`* If we can simplify the input to a constant, then we don't need the`
`@@ -2652,7 +2653,7 @@ eval_const_expressions_mutator(Node *node,`
`2652`	`2653`	`return (Node *) relabel;`
`2653`	`2654`	`}`
`2654`	`2655`	`}`
`2655`		`- if (IsA(node, CaseExpr))`
	`2656`	`+ case T_CaseExpr:`
`2656`	`2657`	`{`
`2657`	`2658`	`/*----------`
`2658`	`2659`	`* CASE expressions can be simplified if there are constant`
`@@ -2783,7 +2784,7 @@ eval_const_expressions_mutator(Node *node,`
`2783`	`2784`	`newcase->location = caseexpr->location;`
`2784`	`2785`	`return (Node *) newcase;`
`2785`	`2786`	`}`
`2786`		`- if (IsA(node, CaseTestExpr))`
	`2787`	`+ case T_CaseTestExpr:`
`2787`	`2788`	`{`
`2788`	`2789`	`/*`
`2789`	`2790`	`* If we know a constant test value for the current CASE construct,`
`@@ -2795,7 +2796,7 @@ eval_const_expressions_mutator(Node *node,`
`2795`	`2796`	`else`
`2796`	`2797`	`return copyObject(node);`
`2797`	`2798`	`}`
`2798`		`- if (IsA(node, ArrayExpr))`
	`2799`	`+ case T_ArrayExpr:`
`2799`	`2800`	`{`
`2800`	`2801`	`ArrayExpr arrayexpr = (ArrayExpr ) node;`
`2801`	`2802`	`ArrayExpr *newarray;`
`@@ -2831,7 +2832,7 @@ eval_const_expressions_mutator(Node *node,`
`2831`	`2832`
`2832`	`2833`	`return (Node *) newarray;`
`2833`	`2834`	`}`
`2834`		`- if (IsA(node, CoalesceExpr))`
	`2835`	`+ case T_CoalesceExpr:`
`2835`	`2836`	`{`
`2836`	`2837`	`CoalesceExpr coalesceexpr = (CoalesceExpr ) node;`
`2837`	`2838`	`CoalesceExpr *newcoalesce;`
`@@ -2878,7 +2879,7 @@ eval_const_expressions_mutator(Node *node,`
`2878`	`2879`	`newcoalesce->location = coalesceexpr->location;`
`2879`	`2880`	`return (Node *) newcoalesce;`
`2880`	`2881`	`}`
`2881`		`- if (IsA(node, FieldSelect))`
	`2882`	`+ case T_FieldSelect:`
`2882`	`2883`	`{`
`2883`	`2884`	`/*`
`2884`	`2885`	`* We can optimize field selection from a whole-row Var into a simple`
`@@ -2941,7 +2942,7 @@ eval_const_expressions_mutator(Node *node,`
`2941`	`2942`	`newfselect->resultcollid = fselect->resultcollid;`
`2942`	`2943`	`return (Node *) newfselect;`
`2943`	`2944`	`}`
`2944`		`- if (IsA(node, NullTest))`
	`2945`	`+ case T_NullTest:`
`2945`	`2946`	`{`
`2946`	`2947`	`NullTest ntest = (NullTest ) node;`
`2947`	`2948`	`NullTest *newntest;`
`@@ -3024,7 +3025,7 @@ eval_const_expressions_mutator(Node *node,`
`3024`	`3025`	`newntest->argisrow = ntest->argisrow;`
`3025`	`3026`	`return (Node *) newntest;`
`3026`	`3027`	`}`
`3027`		`- if (IsA(node, BooleanTest))`
	`3028`	`+ case T_BooleanTest:`
`3028`	`3029`	`{`
`3029`	`3030`	`BooleanTest btest = (BooleanTest ) node;`
`3030`	`3031`	`BooleanTest *newbtest;`
`@@ -3076,19 +3077,24 @@ eval_const_expressions_mutator(Node *node,`
`3076`	`3077`	`newbtest->booltesttype = btest->booltesttype;`
`3077`	`3078`	`return (Node *) newbtest;`
`3078`	`3079`	`}`
`3079`		`- if (IsA(node, PlaceHolderVar) &&context->estimate)`
`3080`		`- {`
	`3080`	`+ case T_PlaceHolderVar:`
`3081`	`3081`	`/*`
`3082`	`3082`	`* In estimation mode, just strip the PlaceHolderVar node altogether;`
`3083`	`3083`	`* this amounts to estimating that the contained value won't be forced`
`3084`	`3084`	`* to null by an outer join. In regular mode we just use the default`
`3085`	`3085`	`* behavior (ie, simplify the expression but leave the PlaceHolderVar`
`3086`	`3086`	`* node intact).`
`3087`	`3087`	`*/`
`3088`		`- PlaceHolderVar phv = (PlaceHolderVar ) node;`
	`3088`	`+ if (context->estimate)`
	`3089`	`+ {`
	`3090`	`+ PlaceHolderVar phv = (PlaceHolderVar ) node;`
`3089`	`3091`
`3090`		`- return eval_const_expressions_mutator((Node *) phv->phexpr,`
`3091`		`- context);`
	`3092`	`+ return eval_const_expressions_mutator((Node *) phv->phexpr,`
	`3093`	`+ context);`
	`3094`	`+ }`
	`3095`	`+ break;`
	`3096`	`+ default:`
	`3097`	`+ break;`
`3092`	`3098`	`}`
`3093`	`3099`
`3094`	`3100`	`/*`