Use fast path in plpgsql's RETURN/RETURN NEXT in more cases.

tglsfdc · tglsfdc · commit 9e3ad1aac524 · 2015-02-16T15:28:48.000-05:00
exec_stmt_return() and exec_stmt_return_next() have fast-path code for
handling a simple variable reference (i.e. "return var") without going
through the full expression evaluation machinery.  For some reason,
pl_gram.y was under the impression that this fast path only applied for
record/row variables; but in reality code for handling regular scalar
variables has been there all along.  Adjusting the logic to allow that
code to be used actually results in a net savings of code in pl_gram.y
(by eliminating some redundancy), and it buys a measurable though not
very impressive amount of speedup.

Noted while fooling with my expanded-array patch, wherein this makes a much
bigger difference because it enables returning an expanded array variable
without an extra flattening step.  But AFAICS this is a win regardless,
so commit it separately.
diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c
@@ -2452,8 +2452,9 @@ exec_stmt_return(PLpgSQL_execstate *estate, PLpgSQL_stmt_return *stmt)
 	estate->retisnull = true;
 
 	/*
-	 * This special-case path covers record/row variables in fn_retistuple
-	 * functions, as well as functions with one or more OUT parameters.
+	 * Special case path when the RETURN expression is a simple variable
+	 * reference; in particular, this path is always taken in functions with
+	 * one or more OUT parameters.
 	 */
 	if (stmt->retvarno >= 0)
 	{
@@ -2576,8 +2577,9 @@ exec_stmt_return_next(PLpgSQL_execstate *estate,
 	natts = tupdesc->natts;
 
 	/*
-	 * This special-case path covers record/row variables in fn_retistuple
-	 * functions, as well as functions with one or more OUT parameters.
+	 * Special case path when the RETURN NEXT expression is a simple variable
+	 * reference; in particular, this path is always taken in functions with
+	 * one or more OUT parameters.
 	 */
 	if (stmt->retvarno >= 0)
 	{
diff --git a/src/pl/plpgsql/src/pl_gram.y b/src/pl/plpgsql/src/pl_gram.y
@@ -3036,16 +3036,17 @@ make_return_stmt(int location)
 					 errmsg("RETURN cannot have a parameter in function returning void"),
 					 parser_errposition(yylloc)));
 	}
-	else if (plpgsql_curr_compile->fn_retistuple)
+	else
 	{
 		/*
-		 * We want to special-case simple row or record references for
-		 * efficiency.  So peek ahead to see if that's what we have.
+		 * We want to special-case simple variable references for efficiency.
+		 * So peek ahead to see if that's what we have.
 		 */
 		int		tok = yylex();
 
 		if (tok == T_DATUM && plpgsql_peek() == ';' &&
-			(yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_ROW ||
+			(yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_VAR ||
+			 yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_ROW ||
 			 yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_REC))
 		{
 			new->retvarno = yylval.wdatum.datum->dno;
@@ -3055,19 +3056,16 @@ make_return_stmt(int location)
 		}
 		else
 		{
-			/* Not (just) a row/record name, so treat as expression */
+			/*
+			 * Not (just) a variable name, so treat as expression.
+			 *
+			 * Note that a well-formed expression is _required_ here;
+			 * anything else is a compile-time error.
+			 */
 			plpgsql_push_back_token(tok);
 			new->expr = read_sql_expression(';', ";");
 		}
 	}
-	else
-	{
-		/*
-		 * Note that a well-formed expression is _required_ here;
-		 * anything else is a compile-time error.
-		 */
-		new->expr = read_sql_expression(';', ";");
-	}
 
 	return (PLpgSQL_stmt *) new;
 }
@@ -3099,16 +3097,17 @@ make_return_next_stmt(int location)
 					 parser_errposition(yylloc)));
 		new->retvarno = plpgsql_curr_compile->out_param_varno;
 	}
-	else if (plpgsql_curr_compile->fn_retistuple)
+	else
 	{
 		/*
-		 * We want to special-case simple row or record references for
-		 * efficiency.  So peek ahead to see if that's what we have.
+		 * We want to special-case simple variable references for efficiency.
+		 * So peek ahead to see if that's what we have.
 		 */
 		int		tok = yylex();
 
 		if (tok == T_DATUM && plpgsql_peek() == ';' &&
-			(yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_ROW ||
+			(yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_VAR ||
+			 yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_ROW ||
 			 yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_REC))
 		{
 			new->retvarno = yylval.wdatum.datum->dno;
@@ -3118,13 +3117,16 @@ make_return_next_stmt(int location)
 		}
 		else
 		{
-			/* Not (just) a row/record name, so treat as expression */
+			/*
+			 * Not (just) a variable name, so treat as expression.
+			 *
+			 * Note that a well-formed expression is _required_ here;
+			 * anything else is a compile-time error.
+			 */
 			plpgsql_push_back_token(tok);
 			new->expr = read_sql_expression(';', ";");
 		}
 	}
-	else
-		new->expr = read_sql_expression(';', ";");
 
 	return (PLpgSQL_stmt *) new;
 }

Original file line number	Diff line number	Diff line change
`@@ -3036,16 +3036,17 @@ make_return_stmt(int location)`
`3036`	`3036`	`errmsg("RETURN cannot have a parameter in function returning void"),`
`3037`	`3037`	`parser_errposition(yylloc)));`
`3038`	`3038`	`}`
`3039`		`- else if (plpgsql_curr_compile->fn_retistuple)`
	`3039`	`+ else`
`3040`	`3040`	`{`
`3041`	`3041`	`/*`
`3042`		`- * We want to special-case simple row or record references for`
`3043`		`- * efficiency. So peek ahead to see if that's what we have.`
	`3042`	`+ * We want to special-case simple variable references for efficiency.`
	`3043`	`+ * So peek ahead to see if that's what we have.`
`3044`	`3044`	`*/`
`3045`	`3045`	`int tok = yylex();`
`3046`	`3046`
`3047`	`3047`	`if (tok == T_DATUM && plpgsql_peek() == ';' &&`
`3048`		`- (yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_ROW \|\|`
	`3048`	`+ (yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_VAR \|\|`
	`3049`	`+ yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_ROW \|\|`
`3049`	`3050`	`yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_REC))`
`3050`	`3051`	`{`
`3051`	`3052`	`new->retvarno = yylval.wdatum.datum->dno;`
`@@ -3055,19 +3056,16 @@ make_return_stmt(int location)`
`3055`	`3056`	`}`
`3056`	`3057`	`else`
`3057`	`3058`	`{`
`3058`		`- /* Not (just) a row/record name, so treat as expression */`
	`3059`	`+ /*`
	`3060`	`+ * Not (just) a variable name, so treat as expression.`
	`3061`	`+ *`
	`3062`	`+ * Note that a well-formed expression is _required_ here;`
	`3063`	`+ * anything else is a compile-time error.`
	`3064`	`+ */`
`3059`	`3065`	`plpgsql_push_back_token(tok);`
`3060`	`3066`	`new->expr = read_sql_expression(';', ";");`
`3061`	`3067`	`}`
`3062`	`3068`	`}`
`3063`		`- else`
`3064`		`- {`
`3065`		`- /*`
`3066`		`- * Note that a well-formed expression is _required_ here;`
`3067`		`- * anything else is a compile-time error.`
`3068`		`- */`
`3069`		`- new->expr = read_sql_expression(';', ";");`
`3070`		`- }`
`3071`	`3069`
`3072`	`3070`	`return (PLpgSQL_stmt *) new;`
`3073`	`3071`	`}`
`@@ -3099,16 +3097,17 @@ make_return_next_stmt(int location)`
`3099`	`3097`	`parser_errposition(yylloc)));`
`3100`	`3098`	`new->retvarno = plpgsql_curr_compile->out_param_varno;`
`3101`	`3099`	`}`
`3102`		`- else if (plpgsql_curr_compile->fn_retistuple)`
	`3100`	`+ else`
`3103`	`3101`	`{`
`3104`	`3102`	`/*`
`3105`		`- * We want to special-case simple row or record references for`
`3106`		`- * efficiency. So peek ahead to see if that's what we have.`
	`3103`	`+ * We want to special-case simple variable references for efficiency.`
	`3104`	`+ * So peek ahead to see if that's what we have.`
`3107`	`3105`	`*/`
`3108`	`3106`	`int tok = yylex();`
`3109`	`3107`
`3110`	`3108`	`if (tok == T_DATUM && plpgsql_peek() == ';' &&`
`3111`		`- (yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_ROW \|\|`
	`3109`	`+ (yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_VAR \|\|`
	`3110`	`+ yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_ROW \|\|`
`3112`	`3111`	`yylval.wdatum.datum->dtype == PLPGSQL_DTYPE_REC))`
`3113`	`3112`	`{`
`3114`	`3113`	`new->retvarno = yylval.wdatum.datum->dno;`
`@@ -3118,13 +3117,16 @@ make_return_next_stmt(int location)`
`3118`	`3117`	`}`
`3119`	`3118`	`else`
`3120`	`3119`	`{`
`3121`		`- /* Not (just) a row/record name, so treat as expression */`
	`3120`	`+ /*`
	`3121`	`+ * Not (just) a variable name, so treat as expression.`
	`3122`	`+ *`
	`3123`	`+ * Note that a well-formed expression is _required_ here;`
	`3124`	`+ * anything else is a compile-time error.`
	`3125`	`+ */`
`3122`	`3126`	`plpgsql_push_back_token(tok);`
`3123`	`3127`	`new->expr = read_sql_expression(';', ";");`
`3124`	`3128`	`}`
`3125`	`3129`	`}`
`3126`		`- else`
`3127`		`- new->expr = read_sql_expression(';', ";");`
`3128`	`3130`
`3129`	`3131`	`return (PLpgSQL_stmt *) new;`
`3130`	`3132`	`}`