PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
nodeSubqueryscan.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * nodeSubqueryscan.c
4  * Support routines for scanning subqueries (subselects in rangetable).
5  *
6  * This is just enough different from sublinks (nodeSubplan.c) to mean that
7  * we need two sets of code. Ought to look at trying to unify the cases.
8  *
9  *
10  * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
11  * Portions Copyright (c) 1994, Regents of the University of California
12  *
13  *
14  * IDENTIFICATION
15  * src/backend/executor/nodeSubqueryscan.c
16  *
17  *-------------------------------------------------------------------------
18  */
19 /*
20  * INTERFACE ROUTINES
21  * ExecSubqueryScan scans a subquery.
22  * ExecSubqueryNext retrieve next tuple in sequential order.
23  * ExecInitSubqueryScan creates and initializes a subqueryscan node.
24  * ExecEndSubqueryScan releases any storage allocated.
25  * ExecReScanSubqueryScan rescans the relation
26  *
27  */
28 #include "postgres.h"
29 
30 #include "executor/execdebug.h"
32 
34 
35 /* ----------------------------------------------------------------
36  * Scan Support
37  * ----------------------------------------------------------------
38  */
39 /* ----------------------------------------------------------------
40  * SubqueryNext
41  *
42  * This is a workhorse for ExecSubqueryScan
43  * ----------------------------------------------------------------
44  */
45 static TupleTableSlot *
47 {
48  TupleTableSlot *slot;
49 
50  /*
51  * Get the next tuple from the sub-query.
52  */
53  slot = ExecProcNode(node->subplan);
54 
55  /*
56  * We just return the subplan's result slot, rather than expending extra
57  * cycles for ExecCopySlot(). (Our own ScanTupleSlot is used only for
58  * EvalPlanQual rechecks.)
59  */
60  return slot;
61 }
62 
63 /*
64  * SubqueryRecheck -- access method routine to recheck a tuple in EvalPlanQual
65  */
66 static bool
68 {
69  /* nothing to check */
70  return true;
71 }
72 
73 /* ----------------------------------------------------------------
74  * ExecSubqueryScan(node)
75  *
76  * Scans the subquery sequentially and returns the next qualifying
77  * tuple.
78  * We call the ExecScan() routine and pass it the appropriate
79  * access method functions.
80  * ----------------------------------------------------------------
81  */
84 {
85  return ExecScan(&node->ss,
88 }
89 
90 /* ----------------------------------------------------------------
91  * ExecInitSubqueryScan
92  * ----------------------------------------------------------------
93  */
95 ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
96 {
97  SubqueryScanState *subquerystate;
98 
99  /* check for unsupported flags */
100  Assert(!(eflags & EXEC_FLAG_MARK));
101 
102  /* SubqueryScan should not have any "normal" children */
103  Assert(outerPlan(node) == NULL);
104  Assert(innerPlan(node) == NULL);
105 
106  /*
107  * create state structure
108  */
109  subquerystate = makeNode(SubqueryScanState);
110  subquerystate->ss.ps.plan = (Plan *) node;
111  subquerystate->ss.ps.state = estate;
112 
113  /*
114  * Miscellaneous initialization
115  *
116  * create expression context for node
117  */
118  ExecAssignExprContext(estate, &subquerystate->ss.ps);
119 
120  /*
121  * initialize child expressions
122  */
123  subquerystate->ss.ps.targetlist = (List *)
125  (PlanState *) subquerystate);
126  subquerystate->ss.ps.qual = (List *)
127  ExecInitExpr((Expr *) node->scan.plan.qual,
128  (PlanState *) subquerystate);
129 
130  /*
131  * tuple table initialization
132  */
133  ExecInitResultTupleSlot(estate, &subquerystate->ss.ps);
134  ExecInitScanTupleSlot(estate, &subquerystate->ss);
135 
136  /*
137  * initialize subquery
138  */
139  subquerystate->subplan = ExecInitNode(node->subplan, estate, eflags);
140 
141  /*
142  * Initialize scan tuple type (needed by ExecAssignScanProjectionInfo)
143  */
144  ExecAssignScanType(&subquerystate->ss,
145  ExecGetResultType(subquerystate->subplan));
146 
147  /*
148  * Initialize result tuple type and projection info.
149  */
150  ExecAssignResultTypeFromTL(&subquerystate->ss.ps);
151  ExecAssignScanProjectionInfo(&subquerystate->ss);
152 
153  return subquerystate;
154 }
155 
156 /* ----------------------------------------------------------------
157  * ExecEndSubqueryScan
158  *
159  * frees any storage allocated through C routines.
160  * ----------------------------------------------------------------
161  */
162 void
164 {
165  /*
166  * Free the exprcontext
167  */
168  ExecFreeExprContext(&node->ss.ps);
169 
170  /*
171  * clean out the upper tuple table
172  */
175 
176  /*
177  * close down subquery
178  */
179  ExecEndNode(node->subplan);
180 }
181 
182 /* ----------------------------------------------------------------
183  * ExecReScanSubqueryScan
184  *
185  * Rescans the relation.
186  * ----------------------------------------------------------------
187  */
188 void
190 {
191  ExecScanReScan(&node->ss);
192 
193  /*
194  * ExecReScan doesn't know about my subplan, so I have to do
195  * changed-parameter signaling myself. This is just as well, because the
196  * subplan has its own memory context in which its chgParam state lives.
197  */
198  if (node->ss.ps.chgParam != NULL)
200 
201  /*
202  * if chgParam of subnode is not null then plan will be re-scanned by
203  * first ExecProcNode.
204  */
205  if (node->subplan->chgParam == NULL)
206  ExecReScan(node->subplan);
207 }
List * qual
Definition: plannodes.h:130
TupleTableSlot * ExecProcNode(PlanState *node)
Definition: execProcnode.c:380
Plan plan
Definition: plannodes.h:305
void ExecInitScanTupleSlot(EState *estate, ScanState *scanstate)
Definition: execTuples.c:842
void ExecEndNode(PlanState *node)
Definition: execProcnode.c:624
TupleTableSlot * ExecScan(ScanState *node, ExecScanAccessMtd accessMtd, ExecScanRecheckMtd recheckMtd)
Definition: execScan.c:121
void ExecReScan(PlanState *node)
Definition: execAmi.c:73
static TupleTableSlot * SubqueryNext(SubqueryScanState *node)
TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Definition: execTuples.c:439
List * qual
Definition: execnodes.h:1061
List * targetlist
Definition: execnodes.h:1060
TupleTableSlot * ss_ScanTupleSlot
Definition: execnodes.h:1290
EState * state
Definition: execnodes.h:1048
void ExecFreeExprContext(PlanState *planstate)
Definition: execUtils.c:684
void ExecAssignResultTypeFromTL(PlanState *planstate)
Definition: execUtils.c:429
void ExecEndSubqueryScan(SubqueryScanState *node)
TupleTableSlot *(* ExecScanAccessMtd)(ScanState *node)
Definition: executor.h:271
PlanState ps
Definition: execnodes.h:1287
bool(* ExecScanRecheckMtd)(ScanState *node, TupleTableSlot *slot)
Definition: executor.h:272
TupleTableSlot * ps_ResultTupleSlot
Definition: execnodes.h:1076
ExprState * ExecInitExpr(Expr *node, PlanState *parent)
Definition: execQual.c:4266
void ExecAssignScanProjectionInfo(ScanState *node)
Definition: execScan.c:235
void ExecInitResultTupleSlot(EState *estate, PlanState *planstate)
Definition: execTuples.c:832
#define innerPlan(node)
Definition: plannodes.h:158
TupleTableSlot * ExecSubqueryScan(SubqueryScanState *node)
SubqueryScanState * ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags)
PlanState * subplan
Definition: execnodes.h:1526
Bitmapset * chgParam
Definition: execnodes.h:1071
#define outerPlan(node)
Definition: plannodes.h:159
void ExecReScanSubqueryScan(SubqueryScanState *node)
Plan * plan
Definition: execnodes.h:1046
void UpdateChangedParamSet(PlanState *node, Bitmapset *newchg)
Definition: execUtils.c:839
#define makeNode(_type_)
Definition: nodes.h:556
#define NULL
Definition: c.h:226
static bool SubqueryRecheck(SubqueryScanState *node, TupleTableSlot *slot)
#define Assert(condition)
Definition: c.h:670
#define EXEC_FLAG_MARK
Definition: executor.h:61
void ExecAssignExprContext(EState *estate, PlanState *planstate)
Definition: execUtils.c:407
TupleDesc ExecGetResultType(PlanState *planstate)
Definition: execUtils.c:458
List * targetlist
Definition: plannodes.h:129
void ExecScanReScan(ScanState *node)
Definition: execScan.c:327
void ExecAssignScanType(ScanState *scanstate, TupleDesc tupDesc)
Definition: execUtils.c:708
PlanState * ExecInitNode(Plan *node, EState *estate, int eflags)
Definition: execProcnode.c:137
Definition: pg_list.h:45
Plan * subplan
Definition: plannodes.h:474