Add special case fast-paths for strict functions

Many STRICT function calls will have one or two arguments, in which
case we can speed up checking for NULL input by avoiding setting up
a loop over the arguments. This adds EEOP_FUNCEXPR_STRICT_1 and the
corresponding EEOP_FUNCEXPR_STRICT_2 for functions with one and two
arguments respectively.

Author: Andres Freund <andres@anarazel.de>
Co-authored-by: Daniel Gustafsson <daniel@yesql.se>
Reviewed-by: Andreas Karlsson <andreas@proxel.se>
Discussion: https://postgr.es/m/415721CE-7D2E-4B74-B5D9-1950083BA03E@yesql.se
Discussion: https://postgr.es/m/20191023163849.sosqbfs5yenocez3@alap3.anarazel.de

diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c
index 0175b152980194c7db498d276d4635135a964d9d..f1569879b529d5390dc5c43f4ff3c045a64de11b 100644 (file)
--- a/src/backend/executor/execExpr.c
+++ b/src/backend/executor/execExpr.c
@@ -2788,7 +2788,15 @@ ExecInitFunc(ExprEvalStep *scratch, Expr *node, List *args, Oid funcid,
        if (pgstat_track_functions <= flinfo->fn_stats)
        {
                if (flinfo->fn_strict && nargs > 0)
-                       scratch->opcode = EEOP_FUNCEXPR_STRICT;
+               {
+                       /* Choose nargs optimized implementation if available. */
+                       if (nargs == 1)
+                               scratch->opcode = EEOP_FUNCEXPR_STRICT_1;
+                       else if (nargs == 2)
+                               scratch->opcode = EEOP_FUNCEXPR_STRICT_2;
+                       else
+                               scratch->opcode = EEOP_FUNCEXPR_STRICT;
+               }
                else
                        scratch->opcode = EEOP_FUNCEXPR;
        }
@@ -3892,6 +3900,8 @@ ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
                {
                        if (strictnulls)
                                scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_NULLS;
+                       else if (strictargs && pertrans->numTransInputs == 1)
+                               scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1;
                        else
                                scratch.opcode = EEOP_AGG_STRICT_INPUT_CHECK_ARGS;
                        scratch.d.agg_strict_input_check.nulls = strictnulls;
@@ -3968,6 +3978,7 @@ ExecBuildAggTrans(AggState *aggstate, AggStatePerPhase phase,
                                as->d.jump.jumpdone = state->steps_len;
                        }
                        else if (as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_ARGS ||
+                                        as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1 ||
                                         as->opcode == EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
                        {
                                Assert(as->d.agg_strict_input_check.jumpnull == -1);

diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index 491ecad8dc664c8e12f8269a51432a4cb4bbbcc6..8a72b5e70a4ec7c09a5ddb29b1eb4b6dd05b0c80 100644 (file)
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -366,7 +366,9 @@ ExecReadyInterpretedExpr(ExprState *state)
                        return;
                }
                else if (step0 == EEOP_CASE_TESTVAL &&
-                                step1 == EEOP_FUNCEXPR_STRICT)
+                                (step1 == EEOP_FUNCEXPR_STRICT ||
+                                 step1 == EEOP_FUNCEXPR_STRICT_1 ||
+                                 step1 == EEOP_FUNCEXPR_STRICT_2))
                {
                        state->evalfunc_private = ExecJustApplyFuncToCase;
                        return;
@@ -498,6 +500,8 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
                &&CASE_EEOP_CONST,
                &&CASE_EEOP_FUNCEXPR,
                &&CASE_EEOP_FUNCEXPR_STRICT,
+               &&CASE_EEOP_FUNCEXPR_STRICT_1,
+               &&CASE_EEOP_FUNCEXPR_STRICT_2,
                &&CASE_EEOP_FUNCEXPR_FUSAGE,
                &&CASE_EEOP_FUNCEXPR_STRICT_FUSAGE,
                &&CASE_EEOP_BOOL_AND_STEP_FIRST,
@@ -575,6 +579,7 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
                &&CASE_EEOP_AGG_STRICT_DESERIALIZE,
                &&CASE_EEOP_AGG_DESERIALIZE,
                &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_ARGS,
+               &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1,
                &&CASE_EEOP_AGG_STRICT_INPUT_CHECK_NULLS,
                &&CASE_EEOP_AGG_PLAIN_PERGROUP_NULLCHECK,
                &&CASE_EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL,
@@ -925,6 +930,7 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
                        EEO_NEXT();
                }
 
+               /* strict function call with more than two arguments */
                EEO_CASE(EEOP_FUNCEXPR_STRICT)
                {
                        FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
@@ -932,6 +938,8 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
                        int                     nargs = op->d.func.nargs;
                        Datum           d;
 
+                       Assert(nargs > 2);
+
                        /* strict function, so check for NULL args */
                        for (int argno = 0; argno < nargs; argno++)
                        {
@@ -950,6 +958,54 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
                        EEO_NEXT();
                }
 
+               /* strict function call with one argument */
+               EEO_CASE(EEOP_FUNCEXPR_STRICT_1)
+               {
+                       FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
+                       NullableDatum *args = fcinfo->args;
+
+                       Assert(op->d.func.nargs == 1);
+
+                       /* strict function, so check for NULL args */
+                       if (args[0].isnull)
+                               *op->resnull = true;
+                       else
+                       {
+                               Datum           d;
+
+                               fcinfo->isnull = false;
+                               d = op->d.func.fn_addr(fcinfo);
+                               *op->resvalue = d;
+                               *op->resnull = fcinfo->isnull;
+                       }
+
+                       EEO_NEXT();
+               }
+
+               /* strict function call with two arguments */
+               EEO_CASE(EEOP_FUNCEXPR_STRICT_2)
+               {
+                       FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
+                       NullableDatum *args = fcinfo->args;
+
+                       Assert(op->d.func.nargs == 2);
+
+                       /* strict function, so check for NULL args */
+                       if (args[0].isnull || args[1].isnull)
+                               *op->resnull = true;
+                       else
+                       {
+                               Datum           d;
+
+                               fcinfo->isnull = false;
+                               d = op->d.func.fn_addr(fcinfo);
+                               *op->resvalue = d;
+                               *op->resnull = fcinfo->isnull;
+                       }
+
+                       EEO_NEXT();
+               }
+
                EEO_CASE(EEOP_FUNCEXPR_FUSAGE)
                {
                        /* not common enough to inline */
@@ -1982,11 +2038,14 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
                 * input is not NULL.
                 */
 
+               /* when checking more than one argument */
                EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_ARGS)
                {
                        NullableDatum *args = op->d.agg_strict_input_check.args;
                        int                     nargs = op->d.agg_strict_input_check.nargs;
 
+                       Assert(nargs > 1);
+
                        for (int argno = 0; argno < nargs; argno++)
                        {
                                if (args[argno].isnull)
@@ -1995,6 +2054,19 @@ ExecInterpExpr(ExprState *state, ExprContext *econtext, bool *isnull)
                        EEO_NEXT();
                }
 
+               /* special case for just one argument */
+               EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1)
+               {
+                       NullableDatum *args = op->d.agg_strict_input_check.args;
+                       PG_USED_FOR_ASSERTS_ONLY int nargs = op->d.agg_strict_input_check.nargs;
+
+                       Assert(nargs == 1);
+
+                       if (args[0].isnull)
+                               EEO_JUMP(op->d.agg_strict_input_check.jumpnull);
+                       EEO_NEXT();
+               }
+
                EEO_CASE(EEOP_AGG_STRICT_INPUT_CHECK_NULLS)
                {
                        bool       *nulls = op->d.agg_strict_input_check.nulls;

diff --git a/src/backend/jit/llvm/llvmjit_expr.c b/src/backend/jit/llvm/llvmjit_expr.c
index 4080b01c17e01cc8558fe1c6500d67a7781c1654..890bcb0b0a79dfd5f347e6f683300f4ba9afb217 100644 (file)
--- a/src/backend/jit/llvm/llvmjit_expr.c
+++ b/src/backend/jit/llvm/llvmjit_expr.c
@@ -662,12 +662,16 @@ llvm_compile_expr(ExprState *state)
 
                        case EEOP_FUNCEXPR:
                        case EEOP_FUNCEXPR_STRICT:
+                       case EEOP_FUNCEXPR_STRICT_1:
+                       case EEOP_FUNCEXPR_STRICT_2:
                                {
                                        FunctionCallInfo fcinfo = op->d.func.fcinfo_data;
                                        LLVMValueRef v_fcinfo_isnull;
                                        LLVMValueRef v_retval;
 
-                                       if (opcode == EEOP_FUNCEXPR_STRICT)
+                                       if (opcode == EEOP_FUNCEXPR_STRICT ||
+                                               opcode == EEOP_FUNCEXPR_STRICT_1 ||
+                                               opcode == EEOP_FUNCEXPR_STRICT_2)
                                        {
                                                LLVMBasicBlockRef b_nonull;
                                                LLVMBasicBlockRef *b_checkargnulls;
@@ -2482,6 +2486,7 @@ llvm_compile_expr(ExprState *state)
                                }
 
                        case EEOP_AGG_STRICT_INPUT_CHECK_ARGS:
+                       case EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1:
                        case EEOP_AGG_STRICT_INPUT_CHECK_NULLS:
                                {
                                        int                     nargs = op->d.agg_strict_input_check.nargs;

diff --git a/src/include/executor/execExpr.h b/src/include/executor/execExpr.h
index fabdf145a8ee6bb9a1507846b86d391fe7c5827a..75366203706cf45820fced8f41868024fd47b537 100644 (file)
--- a/src/include/executor/execExpr.h
+++ b/src/include/executor/execExpr.h
@@ -116,11 +116,13 @@ typedef enum ExprEvalOp
 
        /*
         * Evaluate function call (including OpExprs etc).  For speed, we
-        * distinguish in the opcode whether the function is strict and/or
-        * requires usage stats tracking.
+        * distinguish in the opcode whether the function is strict with 1, 2, or
+        * more arguments and/or requires usage stats tracking.
         */
        EEOP_FUNCEXPR,
        EEOP_FUNCEXPR_STRICT,
+       EEOP_FUNCEXPR_STRICT_1,
+       EEOP_FUNCEXPR_STRICT_2,
        EEOP_FUNCEXPR_FUSAGE,
        EEOP_FUNCEXPR_STRICT_FUSAGE,
 
@@ -276,6 +278,7 @@ typedef enum ExprEvalOp
        EEOP_AGG_STRICT_DESERIALIZE,
        EEOP_AGG_DESERIALIZE,
        EEOP_AGG_STRICT_INPUT_CHECK_ARGS,
+       EEOP_AGG_STRICT_INPUT_CHECK_ARGS_1,
        EEOP_AGG_STRICT_INPUT_CHECK_NULLS,
        EEOP_AGG_PLAIN_PERGROUP_NULLCHECK,
        EEOP_AGG_PLAIN_TRANS_INIT_STRICT_BYVAL,