nodeValuesscan.c File Reference

#include "postgres.h"
#include "executor/executor.h"
#include "executor/nodeValuesscan.h"
#include "jit/jit.h"
#include "optimizer/clauses.h"
#include "utils/expandeddatum.h"

Include dependency graph for nodeValuesscan.c:

Go to the source code of this file.

Functions
static TupleTableSlot *	ValuesNext (ValuesScanState *node)
static bool	ValuesRecheck (ValuesScanState *node, TupleTableSlot *slot)
static TupleTableSlot *	ExecValuesScan (PlanState *pstate)
ValuesScanState *	ExecInitValuesScan (ValuesScan *node, EState *estate, int eflags)
void	ExecReScanValuesScan (ValuesScanState *node)

Function Documentation

ExecInitValuesScan()

ValuesScanState * ExecInitValuesScan	(	ValuesScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 210 of file nodeValuesscan.c.

{
    ValuesScanState *scanstate;
    TupleDesc   tupdesc;
    ListCell   *vtl;
    int         i;
    PlanState  *planstate;
 
    /*
     * ValuesScan should not have any children.
     */
    Assert(outerPlan(node) == NULL);
    Assert(innerPlan(node) == NULL);
 
    /*
     * create new ScanState for node
     */
    scanstate = makeNode(ValuesScanState);
    scanstate->ss.ps.plan = (Plan *) node;
    scanstate->ss.ps.state = estate;
    scanstate->ss.ps.ExecProcNode = ExecValuesScan;
 
    /*
     * Miscellaneous initialization
     */
    planstate = &scanstate->ss.ps;
 
    /*
     * Create expression contexts.  We need two, one for per-sublist
     * processing and one for execScan.c to use for quals and projections. We
     * cheat a little by using ExecAssignExprContext() to build both.
     */
    ExecAssignExprContext(estate, planstate);
    scanstate->rowcontext = planstate->ps_ExprContext;
    ExecAssignExprContext(estate, planstate);
 
    /*
     * Get info about values list, initialize scan slot with it.
     */
    tupdesc = ExecTypeFromExprList((List *) linitial(node->values_lists));
    ExecInitScanTupleSlot(estate, &scanstate->ss, tupdesc, &TTSOpsVirtual);
 
    /*
     * Initialize result type and projection.
     */
    ExecInitResultTypeTL(&scanstate->ss.ps);
    ExecAssignScanProjectionInfo(&scanstate->ss);
 
    /*
     * initialize child expressions
     */
    scanstate->ss.ps.qual =
        ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);
 
    /*
     * Other node-specific setup
     */
    scanstate->curr_idx = -1;
    scanstate->array_len = list_length(node->values_lists);
 
    /*
     * Convert the list of expression sublists into an array for easier
     * addressing at runtime.  Also, detect whether any sublists contain
     * SubPlans; for just those sublists, go ahead and do expression
     * initialization.  (This avoids problems with SubPlans wanting to connect
     * themselves up to the outer plan tree.  Notably, EXPLAIN won't see the
     * subplans otherwise; also we will have troubles with dangling pointers
     * and/or leaked resources if we try to handle SubPlans the same as
     * simpler expressions.)
     */
    scanstate->exprlists = (List **)
        palloc(scanstate->array_len * sizeof(List *));
    scanstate->exprstatelists = (List **)
        palloc0(scanstate->array_len * sizeof(List *));
    i = 0;
    foreach(vtl, node->values_lists)
    {
        List       *exprs = lfirst_node(List, vtl);
 
        scanstate->exprlists[i] = exprs;
 
        /*
         * We can avoid the cost of a contain_subplans() scan in the simple
         * case where there are no SubPlans anywhere.
         */
        if (estate->es_subplanstates &&
            contain_subplans((Node *) exprs))
        {
            int         saved_jit_flags;
 
            /*
             * As these expressions are only used once, disable JIT for them.
             * This is worthwhile because it's common to insert significant
             * amounts of data via VALUES().  Note that this doesn't prevent
             * use of JIT *within* a subplan, since that's initialized
             * separately; this just affects the upper-level subexpressions.
             */
            saved_jit_flags = estate->es_jit_flags;
            estate->es_jit_flags = PGJIT_NONE;
 
            scanstate->exprstatelists[i] = ExecInitExprList(exprs,
                                                            &scanstate->ss.ps);
 
            estate->es_jit_flags = saved_jit_flags;
        }
        i++;
    }
 
    return scanstate;
}

References Assert, contain_subplans(), EState::es_jit_flags, EState::es_subplanstates, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitExprList(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecTypeFromExprList(), ExecValuesScan(), fb(), i, innerPlan, lfirst_node, linitial, list_length(), makeNode, outerPlan, palloc(), palloc0(), PGJIT_NONE, PlanState::ps_ExprContext, ValuesScan::scan, TTSOpsVirtual, and ValuesScan::values_lists.

Referenced by ExecInitNode().

ExecReScanValuesScan()

void ExecReScanValuesScan

(

ValuesScanState *

node

)

Definition at line 328 of file nodeValuesscan.c.

{
    if (node->ss.ps.ps_ResultTupleSlot)
        ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 
    ExecScanReScan(&node->ss);
 
    node->curr_idx = -1;
}

References ValuesScanState::curr_idx, ExecClearTuple(), ExecScanReScan(), ScanState::ps, PlanState::ps_ResultTupleSlot, and ValuesScanState::ss.

Referenced by ExecReScan().

ExecValuesScan()

static TupleTableSlot * ExecValuesScan ( PlanState *  pstate )

static

Definition at line 196 of file nodeValuesscan.c.

{
    ValuesScanState *node = castNode(ValuesScanState, pstate);
 
    return ExecScan(&node->ss,
                    (ExecScanAccessMtd) ValuesNext,
                    (ExecScanRecheckMtd) ValuesRecheck);
}

References castNode, ExecScan(), ValuesScanState::ss, ValuesNext(), and ValuesRecheck().

Referenced by ExecInitValuesScan().

ValuesNext()

static TupleTableSlot * ValuesNext ( ValuesScanState *  node )

static

Definition at line 47 of file nodeValuesscan.c.

{
    TupleTableSlot *slot;
    EState     *estate;
    ExprContext *econtext;
    ScanDirection direction;
    int         curr_idx;
 
    /*
     * get information from the estate and scan state
     */
    estate = node->ss.ps.state;
    direction = estate->es_direction;
    slot = node->ss.ss_ScanTupleSlot;
    econtext = node->rowcontext;
 
    /*
     * Get the next tuple. Return NULL if no more tuples.
     */
    if (ScanDirectionIsForward(direction))
    {
        if (node->curr_idx < node->array_len)
            node->curr_idx++;
    }
    else
    {
        if (node->curr_idx >= 0)
            node->curr_idx--;
    }
 
    /*
     * Always clear the result slot; this is appropriate if we are at the end
     * of the data, and if we're not, we still need it as the first step of
     * the store-virtual-tuple protocol.  It seems wise to clear the slot
     * before we reset the context it might have pointers into.
     */
    ExecClearTuple(slot);
 
    curr_idx = node->curr_idx;
    if (curr_idx >= 0 && curr_idx < node->array_len)
    {
        List       *exprlist = node->exprlists[curr_idx];
        List       *exprstatelist = node->exprstatelists[curr_idx];
        MemoryContext oldContext;
        Datum      *values;
        bool       *isnull;
        ListCell   *lc;
        int         resind;
 
        /*
         * Get rid of any prior cycle's leftovers.  We use ReScanExprContext
         * not just ResetExprContext because we want any registered shutdown
         * callbacks to be called.
         */
        ReScanExprContext(econtext);
 
        /*
         * Do per-VALUES-row work in the per-tuple context.
         */
        oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
 
        /*
         * Unless we already made the expression eval state for this row,
         * build it in the econtext's per-tuple memory.  This is a tad
         * unusual, but we want to delete the eval state again when we move to
         * the next row, to avoid growth of memory requirements over a long
         * values list.  For rows in which that won't work, we already built
         * the eval state at plan startup.
         */
        if (exprstatelist == NIL)
        {
            /*
             * Pass parent as NULL, not my plan node, because we don't want
             * anything in this transient state linking into permanent state.
             * The only expression type that might wish to do so is a SubPlan,
             * and we already checked that there aren't any.
             *
             * Note that passing parent = NULL also disables JIT compilation
             * of the expressions, which is a win, because they're only going
             * to be used once under normal circumstances.
             */
            exprstatelist = ExecInitExprList(exprlist, NULL);
        }
 
        /* parser should have checked all sublists are the same length */
        Assert(list_length(exprstatelist) == slot->tts_tupleDescriptor->natts);
 
        /*
         * Compute the expressions and build a virtual result tuple. We
         * already did ExecClearTuple(slot).
         */
        values = slot->tts_values;
        isnull = slot->tts_isnull;
 
        resind = 0;
        foreach(lc, exprstatelist)
        {
            ExprState  *estate = (ExprState *) lfirst(lc);
            CompactAttribute *attr = TupleDescCompactAttr(slot->tts_tupleDescriptor,
                                                          resind);
 
            values[resind] = ExecEvalExpr(estate,
                                          econtext,
                                          &isnull[resind]);
 
            /*
             * We must force any R/W expanded datums to read-only state, in
             * case they are multiply referenced in the plan node's output
             * expressions, or in case we skip the output projection and the
             * output column is multiply referenced in higher plan nodes.
             */
            values[resind] = MakeExpandedObjectReadOnly(values[resind],
                                                        isnull[resind],
                                                        attr->attlen);
 
            resind++;
        }
 
        MemoryContextSwitchTo(oldContext);
 
        /*
         * And return the virtual tuple.
         */
        ExecStoreVirtualTuple(slot);
    }
 
    return slot;
}

References ValuesScanState::array_len, Assert, CompactAttribute::attlen, ValuesScanState::curr_idx, ExprContext::ecxt_per_tuple_memory, EState::es_direction, ExecClearTuple(), ExecEvalExpr(), ExecInitExprList(), ExecStoreVirtualTuple(), ValuesScanState::exprlists, ValuesScanState::exprstatelists, fb(), lfirst, list_length(), MakeExpandedObjectReadOnly, MemoryContextSwitchTo(), TupleDescData::natts, NIL, ScanState::ps, ReScanExprContext(), ValuesScanState::rowcontext, ScanDirectionIsForward, ValuesScanState::ss, ScanState::ss_ScanTupleSlot, PlanState::state, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, TupleDescCompactAttr(), and values.

Referenced by ExecValuesScan().

ValuesRecheck()

static bool ValuesRecheck ( ValuesScanState *  node, TupleTableSlot *  slot  )

static

Definition at line 180 of file nodeValuesscan.c.

{
    /* nothing to check */
    return true;
}

Referenced by ExecValuesScan().