nodeMaterial.h File Reference

#include "nodes/execnodes.h"

Include dependency graph for nodeMaterial.h:

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

Go to the source code of this file.

Functions
MaterialState *	ExecInitMaterial (Material *node, EState *estate, int eflags)
void	ExecEndMaterial (MaterialState *node)
void	ExecMaterialMarkPos (MaterialState *node)
void	ExecMaterialRestrPos (MaterialState *node)
void	ExecReScanMaterial (MaterialState *node)

Function Documentation

ExecEndMaterial()

void ExecEndMaterial

(

MaterialState *

node

)

Definition at line 240 of file nodeMaterial.c.

{
    /*
     * Release tuplestore resources
     */
    if (node->tuplestorestate != NULL)
        tuplestore_end(node->tuplestorestate);
    node->tuplestorestate = NULL;
 
    /*
     * shut down the subplan
     */
    ExecEndNode(outerPlanState(node));
}

References ExecEndNode(), outerPlanState, tuplestore_end(), and MaterialState::tuplestorestate.

Referenced by ExecEndNode().

ExecInitMaterial()

MaterialState* ExecInitMaterial	(	Material *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 164 of file nodeMaterial.c.

{
    MaterialState *matstate;
    Plan       *outerPlan;
 
    /*
     * create state structure
     */
    matstate = makeNode(MaterialState);
    matstate->ss.ps.plan = (Plan *) node;
    matstate->ss.ps.state = estate;
    matstate->ss.ps.ExecProcNode = ExecMaterial;
 
    /*
     * We must have a tuplestore buffering the subplan output to do backward
     * scan or mark/restore.  We also prefer to materialize the subplan output
     * if we might be called on to rewind and replay it many times. However,
     * if none of these cases apply, we can skip storing the data.
     */
    matstate->eflags = (eflags & (EXEC_FLAG_REWIND |
                                  EXEC_FLAG_BACKWARD |
                                  EXEC_FLAG_MARK));
 
    /*
     * Tuplestore's interpretation of the flag bits is subtly different from
     * the general executor meaning: it doesn't think BACKWARD necessarily
     * means "backwards all the way to start".  If told to support BACKWARD we
     * must include REWIND in the tuplestore eflags, else tuplestore_trim
     * might throw away too much.
     */
    if (eflags & EXEC_FLAG_BACKWARD)
        matstate->eflags |= EXEC_FLAG_REWIND;
 
    matstate->eof_underlying = false;
    matstate->tuplestorestate = NULL;
 
    /*
     * Miscellaneous initialization
     *
     * Materialization nodes don't need ExprContexts because they never call
     * ExecQual or ExecProject.
     */
 
    /*
     * initialize child nodes
     *
     * We shield the child node from the need to support REWIND, BACKWARD, or
     * MARK/RESTORE.
     */
    eflags &= ~(EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK);
 
    outerPlan = outerPlan(node);
    outerPlanState(matstate) = ExecInitNode(outerPlan, estate, eflags);
 
    /*
     * Initialize result type and slot. No need to initialize projection info
     * because this node doesn't do projections.
     *
     * material nodes only return tuples from their materialized relation.
     */
    ExecInitResultTupleSlotTL(&matstate->ss.ps, &TTSOpsMinimalTuple);
    matstate->ss.ps.ps_ProjInfo = NULL;
 
    /*
     * initialize tuple type.
     */
    ExecCreateScanSlotFromOuterPlan(estate, &matstate->ss, &TTSOpsMinimalTuple);
 
    return matstate;
}

References MaterialState::eflags, MaterialState::eof_underlying, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, EXEC_FLAG_REWIND, ExecCreateScanSlotFromOuterPlan(), ExecInitNode(), ExecInitResultTupleSlotTL(), ExecMaterial(), PlanState::ExecProcNode, makeNode, outerPlan, outerPlanState, PlanState::plan, ScanState::ps, PlanState::ps_ProjInfo, MaterialState::ss, PlanState::state, TTSOpsMinimalTuple, and MaterialState::tuplestorestate.

Referenced by ExecInitNode().

ExecMaterialMarkPos()

void ExecMaterialMarkPos

(

MaterialState *

node

)

Definition at line 262 of file nodeMaterial.c.

{
    Assert(node->eflags & EXEC_FLAG_MARK);
 
    /*
     * if we haven't materialized yet, just return.
     */
    if (!node->tuplestorestate)
        return;
 
    /*
     * copy the active read pointer to the mark.
     */
    tuplestore_copy_read_pointer(node->tuplestorestate, 0, 1);
 
    /*
     * since we may have advanced the mark, try to truncate the tuplestore.
     */
    tuplestore_trim(node->tuplestorestate);
}

References Assert(), MaterialState::eflags, EXEC_FLAG_MARK, tuplestore_copy_read_pointer(), tuplestore_trim(), and MaterialState::tuplestorestate.

Referenced by ExecMarkPos().

ExecMaterialRestrPos()

void ExecMaterialRestrPos

(

MaterialState *

node

)

Definition at line 290 of file nodeMaterial.c.

{
    Assert(node->eflags & EXEC_FLAG_MARK);
 
    /*
     * if we haven't materialized yet, just return.
     */
    if (!node->tuplestorestate)
        return;
 
    /*
     * copy the mark to the active read pointer.
     */
    tuplestore_copy_read_pointer(node->tuplestorestate, 1, 0);
}

References Assert(), MaterialState::eflags, EXEC_FLAG_MARK, tuplestore_copy_read_pointer(), and MaterialState::tuplestorestate.

Referenced by ExecRestrPos().

ExecReScanMaterial()

void ExecReScanMaterial

(

MaterialState *

node

)

Definition at line 313 of file nodeMaterial.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 
    if (node->eflags != 0)
    {
        /*
         * If we haven't materialized yet, just return. If outerplan's
         * chgParam is not NULL then it will be re-scanned by ExecProcNode,
         * else no reason to re-scan it at all.
         */
        if (!node->tuplestorestate)
            return;
 
        /*
         * If subnode is to be rescanned then we forget previous stored
         * results; we have to re-read the subplan and re-store.  Also, if we
         * told tuplestore it needn't support rescan, we lose and must
         * re-read.  (This last should not happen in common cases; else our
         * caller lied by not passing EXEC_FLAG_REWIND to us.)
         *
         * Otherwise we can just rewind and rescan the stored output. The
         * state of the subnode does not change.
         */
        if (outerPlan->chgParam != NULL ||
            (node->eflags & EXEC_FLAG_REWIND) == 0)
        {
            tuplestore_end(node->tuplestorestate);
            node->tuplestorestate = NULL;
            if (outerPlan->chgParam == NULL)
                ExecReScan(outerPlan);
            node->eof_underlying = false;
        }
        else
            tuplestore_rescan(node->tuplestorestate);
    }
    else
    {
        /* In this case we are just passing on the subquery's output */
 
        /*
         * if chgParam of subnode is not null then plan will be re-scanned by
         * first ExecProcNode.
         */
        if (outerPlan->chgParam == NULL)
            ExecReScan(outerPlan);
        node->eof_underlying = false;
    }
}

References MaterialState::eflags, MaterialState::eof_underlying, EXEC_FLAG_REWIND, ExecClearTuple(), ExecReScan(), outerPlan, outerPlanState, ScanState::ps, PlanState::ps_ResultTupleSlot, MaterialState::ss, tuplestore_end(), tuplestore_rescan(), and MaterialState::tuplestorestate.

Referenced by ExecReScan().