Header And Logo
|
#include "postgres.h"#include "executor/executor.h"#include "executor/nodeResult.h"#include "utils/memutils.h"
Go to the source code of this file.
Functions | |
| TupleTableSlot * | ExecResult (ResultState *node) |
| void | ExecResultMarkPos (ResultState *node) |
| void | ExecResultRestrPos (ResultState *node) |
| ResultState * | ExecInitResult (Result *node, EState *estate, int eflags) |
| void | ExecEndResult (ResultState *node) |
| void | ExecReScanResult (ResultState *node) |
| void ExecEndResult | ( | ResultState * | node | ) |
Definition at line 276 of file nodeResult.c.
References ExecClearTuple(), ExecEndNode(), ExecFreeExprContext(), outerPlanState, ResultState::ps, and PlanState::ps_ResultTupleSlot.
Referenced by ExecEndNode().
{
/*
* Free the exprcontext
*/
ExecFreeExprContext(&node->ps);
/*
* clean out the tuple table
*/
ExecClearTuple(node->ps.ps_ResultTupleSlot);
/*
* shut down subplans
*/
ExecEndNode(outerPlanState(node));
}
| ResultState* ExecInitResult | ( | Result * | node, | |
| EState * | estate, | |||
| int | eflags | |||
| ) |
Definition at line 206 of file nodeResult.c.
References Assert, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignProjectionInfo(), ExecAssignResultTypeFromTL(), ExecInitExpr(), ExecInitNode(), ExecInitResultTupleSlot(), innerPlan, makeNode, NULL, outerPlan, outerPlanState, Result::plan, PlanState::plan, ResultState::ps, PlanState::ps_TupFromTlist, Plan::qual, PlanState::qual, ResultState::resconstantqual, Result::resconstantqual, ResultState::rs_checkqual, ResultState::rs_done, PlanState::state, Plan::targetlist, and PlanState::targetlist.
Referenced by ExecInitNode().
{
ResultState *resstate;
/* check for unsupported flags */
Assert(!(eflags & (EXEC_FLAG_MARK | EXEC_FLAG_BACKWARD)) ||
outerPlan(node) != NULL);
/*
* create state structure
*/
resstate = makeNode(ResultState);
resstate->ps.plan = (Plan *) node;
resstate->ps.state = estate;
resstate->rs_done = false;
resstate->rs_checkqual = (node->resconstantqual == NULL) ? false : true;
/*
* Miscellaneous initialization
*
* create expression context for node
*/
ExecAssignExprContext(estate, &resstate->ps);
resstate->ps.ps_TupFromTlist = false;
/*
* tuple table initialization
*/
ExecInitResultTupleSlot(estate, &resstate->ps);
/*
* initialize child expressions
*/
resstate->ps.targetlist = (List *)
ExecInitExpr((Expr *) node->plan.targetlist,
(PlanState *) resstate);
resstate->ps.qual = (List *)
ExecInitExpr((Expr *) node->plan.qual,
(PlanState *) resstate);
resstate->resconstantqual = ExecInitExpr((Expr *) node->resconstantqual,
(PlanState *) resstate);
/*
* initialize child nodes
*/
outerPlanState(resstate) = ExecInitNode(outerPlan(node), estate, eflags);
/*
* we don't use inner plan
*/
Assert(innerPlan(node) == NULL);
/*
* initialize tuple type and projection info
*/
ExecAssignResultTypeFromTL(&resstate->ps);
ExecAssignProjectionInfo(&resstate->ps, NULL);
return resstate;
}
| void ExecReScanResult | ( | ResultState * | node | ) |
Definition at line 295 of file nodeResult.c.
References PlanState::chgParam, ExecReScan(), PlanState::lefttree, NULL, ResultState::ps, PlanState::ps_TupFromTlist, ResultState::resconstantqual, ResultState::rs_checkqual, and ResultState::rs_done.
Referenced by ExecReScan().
{
node->rs_done = false;
node->ps.ps_TupFromTlist = false;
node->rs_checkqual = (node->resconstantqual == NULL) ? false : true;
/*
* If chgParam of subnode is not null then plan will be re-scanned by
* first ExecProcNode.
*/
if (node->ps.lefttree &&
node->ps.lefttree->chgParam == NULL)
ExecReScan(node->ps.lefttree);
}
| TupleTableSlot* ExecResult | ( | ResultState * | node | ) |
Definition at line 67 of file nodeResult.c.
References ExprContext::ecxt_outertuple, ExecProcNode(), ExecProject(), ExecQual(), ExprEndResult, ExprMultipleResult, NULL, outerPlanState, ResultState::ps, PlanState::ps_ExprContext, PlanState::ps_ProjInfo, PlanState::ps_TupFromTlist, ResultState::resconstantqual, ResetExprContext, ResultState::rs_checkqual, ResultState::rs_done, and TupIsNull.
Referenced by ExecProcNode().
{
TupleTableSlot *outerTupleSlot;
TupleTableSlot *resultSlot;
PlanState *outerPlan;
ExprContext *econtext;
ExprDoneCond isDone;
econtext = node->ps.ps_ExprContext;
/*
* check constant qualifications like (2 > 1), if not already done
*/
if (node->rs_checkqual)
{
bool qualResult = ExecQual((List *) node->resconstantqual,
econtext,
false);
node->rs_checkqual = false;
if (!qualResult)
{
node->rs_done = true;
return NULL;
}
}
/*
* Check to see if we're still projecting out tuples from a previous scan
* tuple (because there is a function-returning-set in the projection
* expressions). If so, try to project another one.
*/
if (node->ps.ps_TupFromTlist)
{
resultSlot = ExecProject(node->ps.ps_ProjInfo, &isDone);
if (isDone == ExprMultipleResult)
return resultSlot;
/* Done with that source tuple... */
node->ps.ps_TupFromTlist = false;
}
/*
* Reset per-tuple memory context to free any expression evaluation
* storage allocated in the previous tuple cycle. Note this can't happen
* until we're done projecting out tuples from a scan tuple.
*/
ResetExprContext(econtext);
/*
* if rs_done is true then it means that we were asked to return a
* constant tuple and we already did the last time ExecResult() was
* called, OR that we failed the constant qual check. Either way, now we
* are through.
*/
while (!node->rs_done)
{
outerPlan = outerPlanState(node);
if (outerPlan != NULL)
{
/*
* retrieve tuples from the outer plan until there are no more.
*/
outerTupleSlot = ExecProcNode(outerPlan);
if (TupIsNull(outerTupleSlot))
return NULL;
/*
* prepare to compute projection expressions, which will expect to
* access the input tuples as varno OUTER.
*/
econtext->ecxt_outertuple = outerTupleSlot;
}
else
{
/*
* if we don't have an outer plan, then we are just generating the
* results from a constant target list. Do it only once.
*/
node->rs_done = true;
}
/*
* form the result tuple using ExecProject(), and return it --- unless
* the projection produces an empty set, in which case we must loop
* back to see if there are more outerPlan tuples.
*/
resultSlot = ExecProject(node->ps.ps_ProjInfo, &isDone);
if (isDone != ExprEndResult)
{
node->ps.ps_TupFromTlist = (isDone == ExprMultipleResult);
return resultSlot;
}
}
return NULL;
}
| void ExecResultMarkPos | ( | ResultState * | node | ) |
Definition at line 172 of file nodeResult.c.
References DEBUG2, elog, ExecMarkPos(), NULL, outerPlan, and outerPlanState.
Referenced by ExecMarkPos().
{
PlanState *outerPlan = outerPlanState(node);
if (outerPlan != NULL)
ExecMarkPos(outerPlan);
else
elog(DEBUG2, "Result nodes do not support mark/restore");
}
| void ExecResultRestrPos | ( | ResultState * | node | ) |
Definition at line 187 of file nodeResult.c.
References elog, ERROR, ExecRestrPos(), NULL, outerPlan, and outerPlanState.
Referenced by ExecRestrPos().
{
PlanState *outerPlan = outerPlanState(node);
if (outerPlan != NULL)
ExecRestrPos(outerPlan);
else
elog(ERROR, "Result nodes do not support mark/restore");
}
1.7.1