1 /*-------------------------------------------------------------------------
4 * routines to handle append nodes.
6 * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
11 * $Header: /cvsroot/pgsql/src/backend/executor/nodeAppend.c,v 1.43 2001/10/25 05:49:28 momjian Exp $
13 *-------------------------------------------------------------------------
16 * ExecInitAppend - initialize the append node
17 * ExecProcAppend - retrieve the next tuple from the node
18 * ExecEndAppend - shut down the append node
19 * ExecReScanAppend - rescan the append node
22 * Each append node contains a list of one or more subplans which
23 * must be iteratively processed (forwards or backwards).
24 * Tuples are retrieved by executing the 'whichplan'th subplan
25 * until the subplan stops returning tuples, at which point that
26 * plan is shut down and the next started up.
28 * Append nodes don't make use of their left and right
29 * subtrees, rather they maintain a list of subplans so
30 * a typical append node looks like this in the plan tree:
34 * Append -------+------+------+--- nil
39 * Append nodes are currently used for unions, and to support
40 * inheritance queries, where several relations need to be scanned.
41 * For example, in our standard person/student/employee/student-emp
42 * example, where student and employee inherit from person
43 * and student-emp inherits from student and employee, the
46 * retrieve (e.name) from e in person*
51 * Append -------+-------+--------+--------+
53 * nil nil Scan Scan Scan Scan
55 * person employee student student-emp
60 #include "access/heapam.h"
61 #include "executor/execdebug.h"
62 #include "executor/nodeAppend.h"
63 #include "parser/parsetree.h"
65 static bool exec_append_initialize_next(Append *node);
68 /* ----------------------------------------------------------------
69 * exec_append_initialize_next
71 * Sets up the append node state (i.e. the append state node)
72 * for the "next" scan.
74 * Returns t iff there is a "next" scan to process.
75 * ----------------------------------------------------------------
78 exec_append_initialize_next(Append *node)
81 AppendState *appendstate;
85 * get information from the append node
87 estate = node->plan.state;
88 appendstate = node->appendstate;
89 whichplan = appendstate->as_whichplan;
91 if (whichplan < appendstate->as_firstplan)
94 * if scanning in reverse, we start at the last scan in the list
95 * and then proceed back to the first.. in any case we inform
96 * ExecProcAppend that we are at the end of the line by returning
99 appendstate->as_whichplan = appendstate->as_firstplan;
102 else if (whichplan > appendstate->as_lastplan)
105 * as above, end the scan if we go beyond the last scan in our
108 appendstate->as_whichplan = appendstate->as_lastplan;
114 * initialize the scan
116 * If we are controlling the target relation, select the proper
117 * active ResultRelInfo and junk filter for this target.
121 Assert(whichplan < estate->es_num_result_relations);
122 estate->es_result_relation_info =
123 estate->es_result_relations + whichplan;
124 estate->es_junkFilter =
125 estate->es_result_relation_info->ri_junkFilter;
132 /* ----------------------------------------------------------------
135 * Begins all of the subscans of the append node, storing the
136 * scan structures in the 'initialized' vector of the append-state
139 * (This is potentially wasteful, since the entire result of the
140 * append node may not be scanned, but this way all of the
141 * structures get allocated in the executor's top level memory
142 * block instead of that of the call to ExecProcAppend.)
144 * Special case: during an EvalPlanQual recheck query of an inherited
145 * target relation, we only want to initialize and scan the single
146 * subplan that corresponds to the target relation being checked.
147 * ----------------------------------------------------------------
150 ExecInitAppend(Append *node, EState *estate, Plan *parent)
152 AppendState *appendstate;
159 CXT1_printf("ExecInitAppend: context is %d\n", CurrentMemoryContext);
162 * assign execution state to node and get information for append state
164 node->plan.state = estate;
166 appendplans = node->appendplans;
167 nplans = length(appendplans);
169 initialized = (bool *) palloc(nplans * sizeof(bool));
170 MemSet(initialized, 0, nplans * sizeof(bool));
173 * create new AppendState for our append node
175 appendstate = makeNode(AppendState);
176 appendstate->as_nplans = nplans;
177 appendstate->as_initialized = initialized;
179 node->appendstate = appendstate;
182 * Do we want to scan just one subplan? (Special case for
183 * EvalPlanQual) XXX pretty dirty way of determining that this case
186 if (node->isTarget && estate->es_evTuple != NULL)
190 tplan = estate->es_result_relation_info - estate->es_result_relations;
191 Assert(tplan >= 0 && tplan < nplans);
193 appendstate->as_firstplan = tplan;
194 appendstate->as_lastplan = tplan;
198 /* normal case, scan all subplans */
199 appendstate->as_firstplan = 0;
200 appendstate->as_lastplan = nplans - 1;
204 * Miscellaneous initialization
206 * Append plans don't have expression contexts because they never call
207 * ExecQual or ExecProject.
210 #define APPEND_NSLOTS 1
213 * append nodes still have Result slots, which hold pointers to
214 * tuples, so we have to initialize them.
216 ExecInitResultTupleSlot(estate, &appendstate->cstate);
219 * call ExecInitNode on each of the plans to be executed and save the
220 * results into the array "initialized"
222 for (i = appendstate->as_firstplan; i <= appendstate->as_lastplan; i++)
224 appendstate->as_whichplan = i;
225 exec_append_initialize_next(node);
227 initNode = (Plan *) nth(i, appendplans);
228 initialized[i] = ExecInitNode(initNode, estate, (Plan *) node);
232 * initialize tuple type
234 ExecAssignResultTypeFromTL((Plan *) node, &appendstate->cstate);
235 appendstate->cstate.cs_ProjInfo = NULL;
238 * return the result from the first subplan's initialization
240 appendstate->as_whichplan = appendstate->as_firstplan;
241 exec_append_initialize_next(node);
247 ExecCountSlotsAppend(Append *node)
252 foreach(plan, node->appendplans)
253 nSlots += ExecCountSlotsNode((Plan *) lfirst(plan));
254 return nSlots + APPEND_NSLOTS;
257 /* ----------------------------------------------------------------
260 * Handles the iteration over the multiple scans.
262 * NOTE: Can't call this ExecAppend, that name is used in execMain.
263 * ----------------------------------------------------------------
266 ExecProcAppend(Append *node)
269 AppendState *appendstate;
273 TupleTableSlot *result;
274 TupleTableSlot *result_slot;
275 ScanDirection direction;
278 * get information from the node
280 appendstate = node->appendstate;
281 estate = node->plan.state;
282 direction = estate->es_direction;
283 appendplans = node->appendplans;
284 whichplan = appendstate->as_whichplan;
285 result_slot = appendstate->cstate.cs_ResultTupleSlot;
288 * figure out which subplan we are currently processing
290 subnode = (Plan *) nth(whichplan, appendplans);
293 elog(DEBUG, "ExecProcAppend: subnode is NULL");
296 * get a tuple from the subplan
298 result = ExecProcNode(subnode, (Plan *) node);
300 if (!TupIsNull(result))
303 * if the subplan gave us something then place a copy of whatever
304 * we get into our result slot and return it.
306 * Note we rely on the subplan to retain ownership of the tuple for
307 * as long as we need it --- we don't copy it.
309 return ExecStoreTuple(result->val, result_slot, InvalidBuffer, false);
314 * .. go on to the "next" subplan in the appropriate direction and
315 * try processing again (recursively)
317 if (ScanDirectionIsForward(direction))
318 appendstate->as_whichplan++;
320 appendstate->as_whichplan--;
323 * return something from next node or an empty slot if all of our
324 * subplans have been exhausted.
326 if (exec_append_initialize_next(node))
328 ExecSetSlotDescriptorIsNew(result_slot, true);
329 return ExecProcAppend(node);
332 return ExecClearTuple(result_slot);
336 /* ----------------------------------------------------------------
339 * Shuts down the subscans of the append node.
341 * Returns nothing of interest.
342 * ----------------------------------------------------------------
345 ExecEndAppend(Append *node)
348 AppendState *appendstate;
355 * get information from the node
357 appendstate = node->appendstate;
358 estate = node->plan.state;
359 appendplans = node->appendplans;
360 nplans = appendstate->as_nplans;
361 initialized = appendstate->as_initialized;
364 * shut down each of the subscans
366 for (i = 0; i < nplans; i++)
369 ExecEndNode((Plan *) nth(i, appendplans), (Plan *) node);
374 ExecReScanAppend(Append *node, ExprContext *exprCtxt, Plan *parent)
376 AppendState *appendstate = node->appendstate;
379 for (i = appendstate->as_firstplan; i <= appendstate->as_lastplan; i++)
383 subnode = (Plan *) nth(i, node->appendplans);
386 * ExecReScan doesn't know about my subplans, so I have to do
387 * changed-parameter signaling myself.
389 if (node->plan.chgParam != NULL)
390 SetChangedParamList(subnode, node->plan.chgParam);
393 * if chgParam of subnode is not null then plan will be re-scanned
394 * by first ExecProcNode.
396 if (subnode->chgParam == NULL)
398 /* make sure estate is correct for this subnode (needed??) */
399 appendstate->as_whichplan = i;
400 exec_append_initialize_next(node);
401 ExecReScan(subnode, exprCtxt, (Plan *) node);
404 appendstate->as_whichplan = appendstate->as_firstplan;
405 exec_append_initialize_next(node);