nodeNamedtuplestorescan.c File Reference

#include "postgres.h"
#include "executor/executor.h"
#include "executor/nodeNamedtuplestorescan.h"
#include "utils/queryenvironment.h"

Include dependency graph for nodeNamedtuplestorescan.c:

Go to the source code of this file.

Functions
static TupleTableSlot *	NamedTuplestoreScanNext (NamedTuplestoreScanState *node)
static bool	NamedTuplestoreScanRecheck (NamedTuplestoreScanState *node, TupleTableSlot *slot)
static TupleTableSlot *	ExecNamedTuplestoreScan (PlanState *pstate)
NamedTuplestoreScanState *	ExecInitNamedTuplestoreScan (NamedTuplestoreScan *node, EState *estate, int eflags)
void	ExecReScanNamedTuplestoreScan (NamedTuplestoreScanState *node)

Function Documentation

ExecInitNamedTuplestoreScan()

NamedTuplestoreScanState * ExecInitNamedTuplestoreScan	(	NamedTuplestoreScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 82 of file nodeNamedtuplestorescan.c.

{
    NamedTuplestoreScanState *scanstate;
    EphemeralNamedRelation enr;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    /*
     * NamedTuplestoreScan should not have any children.
     */
    Assert(outerPlan(node) == NULL);
    Assert(innerPlan(node) == NULL);
 
    /*
     * create new NamedTuplestoreScanState for node
     */
    scanstate = makeNode(NamedTuplestoreScanState);
    scanstate->ss.ps.plan = (Plan *) node;
    scanstate->ss.ps.state = estate;
    scanstate->ss.ps.ExecProcNode = ExecNamedTuplestoreScan;
 
    enr = get_ENR(estate->es_queryEnv, node->enrname);
    if (!enr)
        elog(ERROR, "executor could not find named tuplestore \"%s\"",
             node->enrname);
 
    Assert(enr->reldata);
    scanstate->relation = (Tuplestorestate *) enr->reldata;
    scanstate->tupdesc = ENRMetadataGetTupDesc(&(enr->md));
    scanstate->readptr =
        tuplestore_alloc_read_pointer(scanstate->relation, EXEC_FLAG_REWIND);
 
    /*
     * The new read pointer copies its position from read pointer 0, which
     * could be anywhere, so explicitly rewind it.
     */
    tuplestore_select_read_pointer(scanstate->relation, scanstate->readptr);
    tuplestore_rescan(scanstate->relation);
 
    /*
     * XXX: Should we add a function to free that read pointer when done?
     *
     * This was attempted, but it did not improve performance or memory usage
     * in any tested cases.
     */
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &scanstate->ss.ps);
 
    /*
     * The scan tuple type is specified for the tuplestore.
     */
    ExecInitScanTupleSlot(estate, &scanstate->ss, scanstate->tupdesc,
                          &TTSOpsMinimalTuple);
 
    /*
     * 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);
 
    return scanstate;
}

References Assert(), elog, ENRMetadataGetTupDesc(), NamedTuplestoreScan::enrname, ERROR, EState::es_queryEnv, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, EXEC_FLAG_REWIND, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecNamedTuplestoreScan(), PlanState::ExecProcNode, get_ENR(), innerPlan, makeNode, EphemeralNamedRelationData::md, outerPlan, PlanState::plan, ScanState::ps, PlanState::qual, NamedTuplestoreScanState::readptr, NamedTuplestoreScanState::relation, EphemeralNamedRelationData::reldata, NamedTuplestoreScan::scan, NamedTuplestoreScanState::ss, PlanState::state, TTSOpsMinimalTuple, NamedTuplestoreScanState::tupdesc, tuplestore_alloc_read_pointer(), tuplestore_rescan(), and tuplestore_select_read_pointer().

Referenced by ExecInitNode().

ExecNamedTuplestoreScan()

static TupleTableSlot * ExecNamedTuplestoreScan ( PlanState *  pstate )

static

Definition at line 67 of file nodeNamedtuplestorescan.c.

{
    NamedTuplestoreScanState *node = castNode(NamedTuplestoreScanState, pstate);
 
    return ExecScan(&node->ss,
                    (ExecScanAccessMtd) NamedTuplestoreScanNext,
                    (ExecScanRecheckMtd) NamedTuplestoreScanRecheck);
}

References castNode, ExecScan(), NamedTuplestoreScanNext(), NamedTuplestoreScanRecheck(), and NamedTuplestoreScanState::ss.

Referenced by ExecInitNamedTuplestoreScan().

ExecReScanNamedTuplestoreScan()

void ExecReScanNamedTuplestoreScan

(

NamedTuplestoreScanState *

node

)

Definition at line 164 of file nodeNamedtuplestorescan.c.

{
    Tuplestorestate *tuplestorestate = node->relation;
 
    if (node->ss.ps.ps_ResultTupleSlot)
        ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 
    ExecScanReScan(&node->ss);
 
    /*
     * Rewind my own pointer.
     */
    tuplestore_select_read_pointer(tuplestorestate, node->readptr);
    tuplestore_rescan(tuplestorestate);
}

References ExecClearTuple(), ExecScanReScan(), ScanState::ps, PlanState::ps_ResultTupleSlot, NamedTuplestoreScanState::readptr, NamedTuplestoreScanState::relation, NamedTuplestoreScanState::ss, tuplestore_rescan(), and tuplestore_select_read_pointer().

Referenced by ExecReScan().

NamedTuplestoreScanNext()

static TupleTableSlot * NamedTuplestoreScanNext ( NamedTuplestoreScanState *  node )

static

Definition at line 31 of file nodeNamedtuplestorescan.c.

{
    TupleTableSlot *slot;
 
    /* We intentionally do not support backward scan. */
    Assert(ScanDirectionIsForward(node->ss.ps.state->es_direction));
 
    /*
     * Get the next tuple from tuplestore. Return NULL if no more tuples.
     */
    slot = node->ss.ss_ScanTupleSlot;
    tuplestore_select_read_pointer(node->relation, node->readptr);
    (void) tuplestore_gettupleslot(node->relation, true, false, slot);
    return slot;
}

References Assert(), EState::es_direction, ScanState::ps, NamedTuplestoreScanState::readptr, NamedTuplestoreScanState::relation, ScanDirectionIsForward, NamedTuplestoreScanState::ss, ScanState::ss_ScanTupleSlot, PlanState::state, tuplestore_gettupleslot(), and tuplestore_select_read_pointer().

Referenced by ExecNamedTuplestoreScan().

NamedTuplestoreScanRecheck()

static bool NamedTuplestoreScanRecheck ( NamedTuplestoreScanState *  node, TupleTableSlot *  slot  )

static

Definition at line 52 of file nodeNamedtuplestorescan.c.

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

Referenced by ExecNamedTuplestoreScan().