nodeSubplan.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeSubplan.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
SubPlanState *	ExecInitSubPlan (SubPlan *subplan, PlanState *parent)
Datum	ExecSubPlan (SubPlanState *node, ExprContext *econtext, bool *isNull)
Size	EstimateSubplanHashTableSpace (double nentries, Size tupleWidth, bool unknownEqFalse)
void	ExecReScanSetParamPlan (SubPlanState *node, PlanState *parent)
void	ExecSetParamPlan (SubPlanState *node, ExprContext *econtext)
void	ExecSetParamPlanMulti (const Bitmapset *params, ExprContext *econtext)

Function Documentation

EstimateSubplanHashTableSpace()

Size EstimateSubplanHashTableSpace ( double  nentries, Size  tupleWidth, bool  unknownEqFalse  )

extern

Definition at line 636 of file nodeSubplan.c.

{
    Size        tab1space,
                tab2space;
 
    /* Estimate size of main hashtable */
    tab1space = EstimateTupleHashTableSpace(nentries,
                                            tupleWidth,
                                            0 /* no additional data */ );
 
    /* Give up if that's already too big */
    if (tab1space >= SIZE_MAX)
        return tab1space;
 
    /* Done if we don't need a hashnulls table */
    if (unknownEqFalse)
        return tab1space;
 
    /*
     * Adjust the rowcount estimate in the same way that buildSubPlanHash
     * will, except that we don't bother with the special case for a single
     * hash column.  (We skip that detail because it'd be notationally painful
     * for our caller to provide the column count, and this table has
     * relatively little impact on the total estimate anyway.)
     */
    nentries /= 16;
    if (nentries < 1)
        nentries = 1;
 
    /*
     * It might be sane to also reduce the tupleWidth, but on the other hand
     * we are not accounting for the space taken by the tuples' null bitmaps.
     * Leave it alone for now.
     */
    tab2space = EstimateTupleHashTableSpace(nentries,
                                            tupleWidth,
                                            0 /* no additional data */ );
 
    /* Guard against overflow */
    if (tab2space >= SIZE_MAX - tab1space)
        return SIZE_MAX;
 
    return tab1space + tab2space;
}

References EstimateTupleHashTableSpace(), and fb().

Referenced by subpath_is_hashable(), and subplan_is_hashable().

ExecInitSubPlan()

SubPlanState * ExecInitSubPlan ( SubPlan *  subplan, PlanState *  parent  )

extern

Definition at line 850 of file nodeSubplan.c.

{
    SubPlanState *sstate = makeNode(SubPlanState);
    EState     *estate = parent->state;
 
    sstate->subplan = subplan;
 
    /* Link the SubPlanState to already-initialized subplan */
    sstate->planstate = (PlanState *) list_nth(estate->es_subplanstates,
                                               subplan->plan_id - 1);
 
    /*
     * This check can fail if the planner mistakenly puts a parallel-unsafe
     * subplan into a parallelized subquery; see ExecSerializePlan.
     */
    if (sstate->planstate == NULL)
        elog(ERROR, "subplan \"%s\" was not initialized",
             subplan->plan_name);
 
    /* Link to parent's state, too */
    sstate->parent = parent;
 
    /* Initialize subexpressions */
    sstate->testexpr = ExecInitExpr((Expr *) subplan->testexpr, parent);
 
    /*
     * initialize my state
     */
    sstate->curTuple = NULL;
    sstate->curArray = PointerGetDatum(NULL);
    sstate->projLeft = NULL;
    sstate->projRight = NULL;
    sstate->hashtable = NULL;
    sstate->hashnulls = NULL;
    sstate->tuplesContext = NULL;
    sstate->innerecontext = NULL;
    sstate->keyColIdx = NULL;
    sstate->tab_eq_funcoids = NULL;
    sstate->tab_hash_funcs = NULL;
    sstate->tab_collations = NULL;
    sstate->cur_eq_funcs = NULL;
 
    /*
     * If this is an initplan, it has output parameters that the parent plan
     * will use, so mark those parameters as needing evaluation.  We don't
     * actually run the subplan until we first need one of its outputs.
     *
     * A CTE subplan's output parameter is never to be evaluated in the normal
     * way, so skip this in that case.
     *
     * Note that we don't set parent->chgParam here: the parent plan hasn't
     * been run yet, so no need to force it to re-run.
     */
    if (subplan->setParam != NIL && subplan->parParam == NIL &&
        subplan->subLinkType != CTE_SUBLINK)
    {
        ListCell   *lst;
 
        foreach(lst, subplan->setParam)
        {
            int         paramid = lfirst_int(lst);
            ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
 
            prm->execPlan = sstate;
        }
    }
 
    /*
     * If we are going to hash the subquery output, initialize relevant stuff.
     * (We don't create the hashtable until needed, though.)
     */
    if (subplan->useHashTable)
    {
        int         ncols,
                    i;
        TupleDesc   tupDescLeft;
        TupleDesc   tupDescRight;
        Oid        *cross_eq_funcoids;
        TupleTableSlot *slot;
        FmgrInfo   *lhs_hash_funcs;
        List       *oplist,
                   *lefttlist,
                   *righttlist;
        ListCell   *l;
 
        /* We need a memory context to hold the hash table(s)' tuples */
        sstate->tuplesContext =
            BumpContextCreate(CurrentMemoryContext,
                              "SubPlan hashed tuples",
                              ALLOCSET_DEFAULT_SIZES);
        /* and a short-lived exprcontext for function evaluation */
        sstate->innerecontext = CreateExprContext(estate);
 
        /*
         * We use ExecProject to evaluate the lefthand and righthand
         * expression lists and form tuples.  (You might think that we could
         * use the sub-select's output tuples directly, but that is not the
         * case if we had to insert any run-time coercions of the sub-select's
         * output datatypes; anyway this avoids storing any resjunk columns
         * that might be in the sub-select's output.)  Run through the
         * combining expressions to build tlists for the lefthand and
         * righthand sides.
         *
         * We also extract the combining operators themselves to initialize
         * the equality and hashing functions for the hash tables.
         */
        if (IsA(subplan->testexpr, OpExpr))
        {
            /* single combining operator */
            oplist = list_make1(subplan->testexpr);
        }
        else if (is_andclause(subplan->testexpr))
        {
            /* multiple combining operators */
            oplist = castNode(BoolExpr, subplan->testexpr)->args;
        }
        else
        {
            /* shouldn't see anything else in a hashable subplan */
            elog(ERROR, "unrecognized testexpr type: %d",
                 (int) nodeTag(subplan->testexpr));
            oplist = NIL;       /* keep compiler quiet */
        }
        ncols = list_length(oplist);
 
        lefttlist = righttlist = NIL;
        sstate->numCols = ncols;
        sstate->keyColIdx = (AttrNumber *) palloc(ncols * sizeof(AttrNumber));
        sstate->tab_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid));
        sstate->tab_collations = (Oid *) palloc(ncols * sizeof(Oid));
        sstate->tab_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
        lhs_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
        sstate->cur_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
        /* we'll need the cross-type equality fns below, but not in sstate */
        cross_eq_funcoids = (Oid *) palloc(ncols * sizeof(Oid));
 
        i = 1;
        foreach(l, oplist)
        {
            OpExpr     *opexpr = lfirst_node(OpExpr, l);
            Expr       *expr;
            TargetEntry *tle;
            Oid         rhs_eq_oper;
            Oid         left_hashfn;
            Oid         right_hashfn;
 
            Assert(list_length(opexpr->args) == 2);
 
            /* Process lefthand argument */
            expr = (Expr *) linitial(opexpr->args);
            tle = makeTargetEntry(expr,
                                  i,
                                  NULL,
                                  false);
            lefttlist = lappend(lefttlist, tle);
 
            /* Process righthand argument */
            expr = (Expr *) lsecond(opexpr->args);
            tle = makeTargetEntry(expr,
                                  i,
                                  NULL,
                                  false);
            righttlist = lappend(righttlist, tle);
 
            /* Lookup the equality function (potentially cross-type) */
            cross_eq_funcoids[i - 1] = opexpr->opfuncid;
            fmgr_info(opexpr->opfuncid, &sstate->cur_eq_funcs[i - 1]);
            fmgr_info_set_expr((Node *) opexpr, &sstate->cur_eq_funcs[i - 1]);
 
            /* Look up the equality function for the RHS type */
            if (!get_compatible_hash_operators(opexpr->opno,
                                               NULL, &rhs_eq_oper))
                elog(ERROR, "could not find compatible hash operator for operator %u",
                     opexpr->opno);
            sstate->tab_eq_funcoids[i - 1] = get_opcode(rhs_eq_oper);
 
            /* Lookup the associated hash functions */
            if (!get_op_hash_functions(opexpr->opno,
                                       &left_hashfn, &right_hashfn))
                elog(ERROR, "could not find hash function for hash operator %u",
                     opexpr->opno);
            fmgr_info(left_hashfn, &lhs_hash_funcs[i - 1]);
            fmgr_info(right_hashfn, &sstate->tab_hash_funcs[i - 1]);
 
            /* Set collation */
            sstate->tab_collations[i - 1] = opexpr->inputcollid;
 
            /* keyColIdx is just column numbers 1..n */
            sstate->keyColIdx[i - 1] = i;
 
            i++;
        }
 
        /*
         * Construct tupdescs, slots and projection nodes for left and right
         * sides.  The lefthand expressions will be evaluated in the parent
         * plan node's exprcontext, which we don't have access to here.
         * Fortunately we can just pass NULL for now and fill it in later
         * (hack alert!).  The righthand expressions will be evaluated in our
         * own innerecontext.
         */
        tupDescLeft = ExecTypeFromTL(lefttlist);
        slot = ExecInitExtraTupleSlot(estate, tupDescLeft, &TTSOpsVirtual);
        sstate->projLeft = ExecBuildProjectionInfo(lefttlist,
                                                   NULL,
                                                   slot,
                                                   parent,
                                                   NULL);
 
        sstate->descRight = tupDescRight = ExecTypeFromTL(righttlist);
        slot = ExecInitExtraTupleSlot(estate, tupDescRight, &TTSOpsVirtual);
        sstate->projRight = ExecBuildProjectionInfo(righttlist,
                                                    sstate->innerecontext,
                                                    slot,
                                                    sstate->planstate,
                                                    NULL);
 
        /* Build the ExprState for generating hash values */
        sstate->lhs_hash_expr = ExecBuildHash32FromAttrs(tupDescLeft,
                                                         &TTSOpsVirtual,
                                                         lhs_hash_funcs,
                                                         sstate->tab_collations,
                                                         sstate->numCols,
                                                         sstate->keyColIdx,
                                                         parent,
                                                         0);
 
        /*
         * Create comparator for lookups of rows in the table (potentially
         * cross-type comparisons).
         */
        sstate->cur_eq_comp = ExecBuildGroupingEqual(tupDescLeft, tupDescRight,
                                                     &TTSOpsVirtual, &TTSOpsMinimalTuple,
                                                     ncols,
                                                     sstate->keyColIdx,
                                                     cross_eq_funcoids,
                                                     sstate->tab_collations,
                                                     parent);
    }
 
    return sstate;
}

References ALLOCSET_DEFAULT_SIZES, OpExpr::args, Assert, BumpContextCreate(), castNode, CreateExprContext(), CTE_SUBLINK, SubPlanState::cur_eq_comp, SubPlanState::cur_eq_funcs, SubPlanState::curArray, CurrentMemoryContext, SubPlanState::curTuple, SubPlanState::descRight, elog, ERROR, EState::es_param_exec_vals, EState::es_subplanstates, ExecBuildGroupingEqual(), ExecBuildHash32FromAttrs(), ExecBuildProjectionInfo(), ExecInitExpr(), ExecInitExtraTupleSlot(), ParamExecData::execPlan, ExecTypeFromTL(), fb(), fmgr_info(), fmgr_info_set_expr, get_compatible_hash_operators(), get_op_hash_functions(), get_opcode(), SubPlanState::hashnulls, SubPlanState::hashtable, i, SubPlanState::innerecontext, is_andclause(), IsA, SubPlanState::keyColIdx, lappend(), lfirst_int, lfirst_node, SubPlanState::lhs_hash_expr, linitial, list_length(), list_make1, list_nth(), lsecond, makeNode, makeTargetEntry(), NIL, nodeTag, SubPlanState::numCols, OpExpr::opno, palloc(), SubPlanState::parent, SubPlan::parParam, SubPlan::plan_id, SubPlan::plan_name, SubPlanState::planstate, PointerGetDatum(), SubPlanState::projLeft, SubPlanState::projRight, SubPlan::setParam, PlanState::state, SubPlan::subLinkType, SubPlanState::subplan, SubPlanState::tab_collations, SubPlanState::tab_eq_funcoids, SubPlanState::tab_hash_funcs, SubPlanState::testexpr, SubPlan::testexpr, TTSOpsMinimalTuple, TTSOpsVirtual, SubPlanState::tuplesContext, and SubPlan::useHashTable.

Referenced by ExecInitNode(), and ExecInitSubPlanExpr().

ExecReScanSetParamPlan()

void ExecReScanSetParamPlan ( SubPlanState *  node, PlanState *  parent  )

extern

Definition at line 1317 of file nodeSubplan.c.

{
    PlanState  *planstate = node->planstate;
    SubPlan    *subplan = node->subplan;
    EState     *estate = parent->state;
    ListCell   *l;
 
    /* sanity checks */
    if (subplan->parParam != NIL)
        elog(ERROR, "direct correlated subquery unsupported as initplan");
    if (subplan->setParam == NIL)
        elog(ERROR, "setParam list of initplan is empty");
    if (bms_is_empty(planstate->plan->extParam))
        elog(ERROR, "extParam set of initplan is empty");
 
    /*
     * Don't actually re-scan: it'll happen inside ExecSetParamPlan if needed.
     */
 
    /*
     * Mark this subplan's output parameters as needing recalculation.
     *
     * CTE subplans are never executed via parameter recalculation; instead
     * they get run when called by nodeCtescan.c.  So don't mark the output
     * parameter of a CTE subplan as dirty, but do set the chgParam bit for it
     * so that dependent plan nodes will get told to rescan.
     */
    foreach(l, subplan->setParam)
    {
        int         paramid = lfirst_int(l);
        ParamExecData *prm = &(estate->es_param_exec_vals[paramid]);
 
        if (subplan->subLinkType != CTE_SUBLINK)
            prm->execPlan = node;
 
        parent->chgParam = bms_add_member(parent->chgParam, paramid);
    }
}

References bms_add_member(), bms_is_empty, PlanState::chgParam, CTE_SUBLINK, elog, ERROR, EState::es_param_exec_vals, ParamExecData::execPlan, Plan::extParam, fb(), lfirst_int, NIL, SubPlan::parParam, PlanState::plan, SubPlanState::planstate, SubPlan::setParam, PlanState::state, SubPlan::subLinkType, and SubPlanState::subplan.

Referenced by ExecReScan().

ExecSetParamPlan()

void ExecSetParamPlan ( SubPlanState *  node, ExprContext *  econtext  )

extern

Definition at line 1118 of file nodeSubplan.c.

{
    SubPlan    *subplan = node->subplan;
    PlanState  *planstate = node->planstate;
    SubLinkType subLinkType = subplan->subLinkType;
    EState     *estate = planstate->state;
    ScanDirection dir = estate->es_direction;
    MemoryContext oldcontext;
    TupleTableSlot *slot;
    ListCell   *l;
    bool        found = false;
    ArrayBuildStateAny *astate = NULL;
 
    if (subLinkType == ANY_SUBLINK ||
        subLinkType == ALL_SUBLINK)
        elog(ERROR, "ANY/ALL subselect unsupported as initplan");
    if (subLinkType == CTE_SUBLINK)
        elog(ERROR, "CTE subplans should not be executed via ExecSetParamPlan");
    if (subplan->parParam || subplan->args)
        elog(ERROR, "correlated subplans should not be executed via ExecSetParamPlan");
 
    /*
     * Enforce forward scan direction regardless of caller. It's hard but not
     * impossible to get here in backward scan, so make it work anyway.
     */
    estate->es_direction = ForwardScanDirection;
 
    /* Initialize ArrayBuildStateAny in caller's context, if needed */
    if (subLinkType == ARRAY_SUBLINK)
        astate = initArrayResultAny(subplan->firstColType,
                                    CurrentMemoryContext, true);
 
    /*
     * Must switch to per-query memory context.
     */
    oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
 
    /*
     * Run the plan.  (If it needs to be rescanned, the first ExecProcNode
     * call will take care of that.)
     */
    for (slot = ExecProcNode(planstate);
         !TupIsNull(slot);
         slot = ExecProcNode(planstate))
    {
        TupleDesc   tdesc = slot->tts_tupleDescriptor;
        int         i = 1;
 
        if (subLinkType == EXISTS_SUBLINK)
        {
            /* There can be only one setParam... */
            int         paramid = linitial_int(subplan->setParam);
            ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
 
            prm->execPlan = NULL;
            prm->value = BoolGetDatum(true);
            prm->isnull = false;
            found = true;
            break;
        }
 
        if (subLinkType == ARRAY_SUBLINK)
        {
            Datum       dvalue;
            bool        disnull;
 
            found = true;
            /* stash away current value */
            Assert(subplan->firstColType == TupleDescAttr(tdesc, 0)->atttypid);
            dvalue = slot_getattr(slot, 1, &disnull);
            astate = accumArrayResultAny(astate, dvalue, disnull,
                                         subplan->firstColType, oldcontext);
            /* keep scanning subplan to collect all values */
            continue;
        }
 
        if (found &&
            (subLinkType == EXPR_SUBLINK ||
             subLinkType == MULTIEXPR_SUBLINK ||
             subLinkType == ROWCOMPARE_SUBLINK))
            ereport(ERROR,
                    (errcode(ERRCODE_CARDINALITY_VIOLATION),
                     errmsg("more than one row returned by a subquery used as an expression")));
 
        found = true;
 
        /*
         * We need to copy the subplan's tuple into our own context, in case
         * any of the params are pass-by-ref type --- the pointers stored in
         * the param structs will point at this copied tuple! node->curTuple
         * keeps track of the copied tuple for eventual freeing.
         */
        if (node->curTuple)
            heap_freetuple(node->curTuple);
        node->curTuple = ExecCopySlotHeapTuple(slot);
 
        /*
         * Now set all the setParam params from the columns of the tuple
         */
        foreach(l, subplan->setParam)
        {
            int         paramid = lfirst_int(l);
            ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
 
            prm->execPlan = NULL;
            prm->value = heap_getattr(node->curTuple, i, tdesc,
                                      &(prm->isnull));
            i++;
        }
    }
 
    if (subLinkType == ARRAY_SUBLINK)
    {
        /* There can be only one setParam... */
        int         paramid = linitial_int(subplan->setParam);
        ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
 
        /*
         * We build the result array in query context so it won't disappear;
         * to avoid leaking memory across repeated calls, we have to remember
         * the latest value, much as for curTuple above.
         */
        if (node->curArray != PointerGetDatum(NULL))
            pfree(DatumGetPointer(node->curArray));
        node->curArray = makeArrayResultAny(astate,
                                            econtext->ecxt_per_query_memory,
                                            true);
        prm->execPlan = NULL;
        prm->value = node->curArray;
        prm->isnull = false;
    }
    else if (!found)
    {
        if (subLinkType == EXISTS_SUBLINK)
        {
            /* There can be only one setParam... */
            int         paramid = linitial_int(subplan->setParam);
            ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
 
            prm->execPlan = NULL;
            prm->value = BoolGetDatum(false);
            prm->isnull = false;
        }
        else
        {
            /* For other sublink types, set all the output params to NULL */
            foreach(l, subplan->setParam)
            {
                int         paramid = lfirst_int(l);
                ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
 
                prm->execPlan = NULL;
                prm->value = (Datum) 0;
                prm->isnull = true;
            }
        }
    }
 
    MemoryContextSwitchTo(oldcontext);
 
    /* restore scan direction */
    estate->es_direction = dir;
}

References accumArrayResultAny(), ALL_SUBLINK, ANY_SUBLINK, SubPlan::args, ARRAY_SUBLINK, Assert, BoolGetDatum(), CTE_SUBLINK, SubPlanState::curArray, CurrentMemoryContext, SubPlanState::curTuple, DatumGetPointer(), ExprContext::ecxt_param_exec_vals, ExprContext::ecxt_per_query_memory, elog, ereport, errcode(), errmsg(), ERROR, EState::es_direction, ExecCopySlotHeapTuple(), ParamExecData::execPlan, ExecProcNode(), EXISTS_SUBLINK, EXPR_SUBLINK, fb(), SubPlan::firstColType, ForwardScanDirection, heap_freetuple(), heap_getattr(), i, initArrayResultAny(), lfirst_int, linitial_int, makeArrayResultAny(), MemoryContextSwitchTo(), MULTIEXPR_SUBLINK, SubPlan::parParam, pfree(), SubPlanState::planstate, PointerGetDatum(), ROWCOMPARE_SUBLINK, SubPlan::setParam, slot_getattr(), PlanState::state, SubPlan::subLinkType, SubPlanState::subplan, TupleTableSlot::tts_tupleDescriptor, TupIsNull, and TupleDescAttr().

Referenced by ExecEvalParamExec(), and ExecSetParamPlanMulti().

ExecSetParamPlanMulti()

void ExecSetParamPlanMulti ( const Bitmapset *  params, ExprContext *  econtext  )

extern

Definition at line 1294 of file nodeSubplan.c.

{
    int         paramid;
 
    paramid = -1;
    while ((paramid = bms_next_member(params, paramid)) >= 0)
    {
        ParamExecData *prm = &(econtext->ecxt_param_exec_vals[paramid]);
 
        if (prm->execPlan != NULL)
        {
            /* Parameter not evaluated yet, so go do it */
            ExecSetParamPlan(prm->execPlan, econtext);
            /* ExecSetParamPlan should have processed this param... */
            Assert(prm->execPlan == NULL);
        }
    }
}

References Assert, bms_next_member(), ExprContext::ecxt_param_exec_vals, ExecSetParamPlan(), and fb().

Referenced by EvalPlanQualBegin(), EvalPlanQualStart(), ExecInitParallelPlan(), and ExecParallelReinitialize().

ExecSubPlan()

Datum ExecSubPlan ( SubPlanState *  node, ExprContext *  econtext, bool *  isNull  )

extern

Definition at line 59 of file nodeSubplan.c.

{
    SubPlan    *subplan = node->subplan;
    EState     *estate = node->planstate->state;
    ScanDirection dir = estate->es_direction;
    Datum       retval;
 
    CHECK_FOR_INTERRUPTS();
 
    /* Set non-null as default */
    *isNull = false;
 
    /* Sanity checks */
    if (subplan->subLinkType == CTE_SUBLINK)
        elog(ERROR, "CTE subplans should not be executed via ExecSubPlan");
    if (subplan->setParam != NIL && subplan->subLinkType != MULTIEXPR_SUBLINK)
        elog(ERROR, "cannot set parent params from subquery");
 
    /* Force forward-scan mode for evaluation */
    estate->es_direction = ForwardScanDirection;
 
    /* Select appropriate evaluation strategy */
    if (subplan->useHashTable)
        retval = ExecHashSubPlan(node, econtext, isNull);
    else
        retval = ExecScanSubPlan(node, econtext, isNull);
 
    /* restore scan direction */
    estate->es_direction = dir;
 
    return retval;
}

References CHECK_FOR_INTERRUPTS, CTE_SUBLINK, elog, ERROR, EState::es_direction, ExecHashSubPlan(), ExecScanSubPlan(), ForwardScanDirection, MULTIEXPR_SUBLINK, NIL, SubPlanState::planstate, SubPlan::setParam, PlanState::state, SubPlan::subLinkType, SubPlanState::subplan, and SubPlan::useHashTable.

Referenced by ExecEvalSubPlan().