#include "nodes/execnodes.h"

Include dependency graph for nodeMaterial.h:

This graph shows which files directly or indirectly include 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.

 {
     /*
      * clean out the tuple table
      */
     ExecClearTuple(node->ss.ss_ScanTupleSlot);
  
     /*
      * Release tuplestore resources
      */
     if (node->tuplestorestate != NULL)
         tuplestore_end(node->tuplestorestate);
     node->tuplestorestate = NULL;
  
     /*
      * shut down the subplan
      */
     ExecEndNode(outerPlanState(node));
 }

References ExecClearTuple(), ExecEndNode(), outerPlanState, MaterialState::ss, ScanState::ss_ScanTupleSlot, 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 267 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 295 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 318 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.