granicus.if.org Git - postgresql/blob - src/backend/executor/nodeAppend.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * nodeAppend.c
   4  *        routines to handle append nodes.
   5  *
   6  * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        src/backend/executor/nodeAppend.c
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 /* INTERFACE ROUTINES
  16  *              ExecInitAppend  - initialize the append node
  17  *              ExecAppend              - retrieve the next tuple from the node
  18  *              ExecEndAppend   - shut down the append node
  19  *              ExecReScanAppend - rescan the append node
  20  *
  21  *       NOTES
  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.
  27  *
  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:
  31  *
  32  *                                 ...
  33  *                                 /
  34  *                              Append -------+------+------+--- nil
  35  *                              /       \                 |              |              |
  36  *                        nil   nil              ...    ...    ...
  37  *                                                               subplans
  38  *
  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
  44  *              query:
  45  *
  46  *                              select name from person
  47  *
  48  *              generates the plan:
  49  *
  50  *                                |
  51  *                              Append -------+-------+--------+--------+
  52  *                              /       \                 |               |                |            |
  53  *                        nil   nil              Scan    Scan     Scan     Scan
  54  *                                                        |               |                |            |
  55  *                                                      person employee student student-emp
  56  */
  57
  58 #include "postgres.h"
  59
  60 #include "executor/execdebug.h"
  61 #include "executor/nodeAppend.h"
  62 #include "miscadmin.h"
  63
  64 static TupleTableSlot *ExecAppend(PlanState *pstate);
  65 static bool exec_append_initialize_next(AppendState *appendstate);
  66
  67
  68 /* ----------------------------------------------------------------
  69  *              exec_append_initialize_next
  70  *
  71  *              Sets up the append state node for the "next" scan.
  72  *
  73  *              Returns t iff there is a "next" scan to process.
  74  * ----------------------------------------------------------------
  75  */
  76 static bool
  77 exec_append_initialize_next(AppendState *appendstate)
  78 {
  79         int                     whichplan;
  80
  81         /*
  82          * get information from the append node
  83          */
  84         whichplan = appendstate->as_whichplan;
  85
  86         if (whichplan < 0)
  87         {
  88                 /*
  89                  * if scanning in reverse, we start at the last scan in the list and
  90                  * then proceed back to the first.. in any case we inform ExecAppend
  91                  * that we are at the end of the line by returning FALSE
  92                  */
  93                 appendstate->as_whichplan = 0;
  94                 return FALSE;
  95         }
  96         else if (whichplan >= appendstate->as_nplans)
  97         {
  98                 /*
  99                  * as above, end the scan if we go beyond the last scan in our list..
 100                  */
 101                 appendstate->as_whichplan = appendstate->as_nplans - 1;
 102                 return FALSE;
 103         }
 104         else
 105         {
 106                 return TRUE;
 107         }
 108 }
 109
 110 /* ----------------------------------------------------------------
 111  *              ExecInitAppend
 112  *
 113  *              Begin all of the subscans of the append node.
 114  *
 115  *         (This is potentially wasteful, since the entire result of the
 116  *              append node may not be scanned, but this way all of the
 117  *              structures get allocated in the executor's top level memory
 118  *              block instead of that of the call to ExecAppend.)
 119  * ----------------------------------------------------------------
 120  */
 121 AppendState *
 122 ExecInitAppend(Append *node, EState *estate, int eflags)
 123 {
 124         AppendState *appendstate = makeNode(AppendState);
 125         PlanState **appendplanstates;
 126         int                     nplans;
 127         int                     i;
 128         ListCell   *lc;
 129
 130         /* check for unsupported flags */
 131         Assert(!(eflags & EXEC_FLAG_MARK));
 132
 133         /*
 134          * Lock the non-leaf tables in the partition tree controlled by this node.
 135          * It's a no-op for non-partitioned parent tables.
 136          */
 137         ExecLockNonLeafAppendTables(node->partitioned_rels, estate);
 138
 139         /*
 140          * Set up empty vector of subplan states
 141          */
 142         nplans = list_length(node->appendplans);
 143
 144         appendplanstates = (PlanState **) palloc0(nplans * sizeof(PlanState *));
 145
 146         /*
 147          * create new AppendState for our append node
 148          */
 149         appendstate->ps.plan = (Plan *) node;
 150         appendstate->ps.state = estate;
 151         appendstate->ps.ExecProcNode = ExecAppend;
 152         appendstate->appendplans = appendplanstates;
 153         appendstate->as_nplans = nplans;
 154
 155         /*
 156          * Miscellaneous initialization
 157          *
 158          * Append plans don't have expression contexts because they never call
 159          * ExecQual or ExecProject.
 160          */
 161
 162         /*
 163          * append nodes still have Result slots, which hold pointers to tuples, so
 164          * we have to initialize them.
 165          */
 166         ExecInitResultTupleSlot(estate, &appendstate->ps);
 167
 168         /*
 169          * call ExecInitNode on each of the plans to be executed and save the
 170          * results into the array "appendplans".
 171          */
 172         i = 0;
 173         foreach(lc, node->appendplans)
 174         {
 175                 Plan       *initNode = (Plan *) lfirst(lc);
 176
 177                 appendplanstates[i] = ExecInitNode(initNode, estate, eflags);
 178                 i++;
 179         }
 180
 181         /*
 182          * initialize output tuple type
 183          */
 184         ExecAssignResultTypeFromTL(&appendstate->ps);
 185         appendstate->ps.ps_ProjInfo = NULL;
 186
 187         /*
 188          * initialize to scan first subplan
 189          */
 190         appendstate->as_whichplan = 0;
 191         exec_append_initialize_next(appendstate);
 192
 193         return appendstate;
 194 }
 195
 196 /* ----------------------------------------------------------------
 197  *         ExecAppend
 198  *
 199  *              Handles iteration over multiple subplans.
 200  * ----------------------------------------------------------------
 201  */
 202 static TupleTableSlot *
 203 ExecAppend(PlanState *pstate)
 204 {
 205         AppendState *node = castNode(AppendState, pstate);
 206
 207         for (;;)
 208         {
 209                 PlanState  *subnode;
 210                 TupleTableSlot *result;
 211
 212                 CHECK_FOR_INTERRUPTS();
 213
 214                 /*
 215                  * figure out which subplan we are currently processing
 216                  */
 217                 subnode = node->appendplans[node->as_whichplan];
 218
 219                 /*
 220                  * get a tuple from the subplan
 221                  */
 222                 result = ExecProcNode(subnode);
 223
 224                 if (!TupIsNull(result))
 225                 {
 226                         /*
 227                          * If the subplan gave us something then return it as-is. We do
 228                          * NOT make use of the result slot that was set up in
 229                          * ExecInitAppend; there's no need for it.
 230                          */
 231                         return result;
 232                 }
 233
 234                 /*
 235                  * Go on to the "next" subplan in the appropriate direction. If no
 236                  * more subplans, return the empty slot set up for us by
 237                  * ExecInitAppend.
 238                  */
 239                 if (ScanDirectionIsForward(node->ps.state->es_direction))
 240                         node->as_whichplan++;
 241                 else
 242                         node->as_whichplan--;
 243                 if (!exec_append_initialize_next(node))
 244                         return ExecClearTuple(node->ps.ps_ResultTupleSlot);
 245
 246                 /* Else loop back and try to get a tuple from the new subplan */
 247         }
 248 }
 249
 250 /* ----------------------------------------------------------------
 251  *              ExecEndAppend
 252  *
 253  *              Shuts down the subscans of the append node.
 254  *
 255  *              Returns nothing of interest.
 256  * ----------------------------------------------------------------
 257  */
 258 void
 259 ExecEndAppend(AppendState *node)
 260 {
 261         PlanState **appendplans;
 262         int                     nplans;
 263         int                     i;
 264
 265         /*
 266          * get information from the node
 267          */
 268         appendplans = node->appendplans;
 269         nplans = node->as_nplans;
 270
 271         /*
 272          * shut down each of the subscans
 273          */
 274         for (i = 0; i < nplans; i++)
 275                 ExecEndNode(appendplans[i]);
 276 }
 277
 278 void
 279 ExecReScanAppend(AppendState *node)
 280 {
 281         int                     i;
 282
 283         for (i = 0; i < node->as_nplans; i++)
 284         {
 285                 PlanState  *subnode = node->appendplans[i];
 286
 287                 /*
 288                  * ExecReScan doesn't know about my subplans, so I have to do
 289                  * changed-parameter signaling myself.
 290                  */
 291                 if (node->ps.chgParam != NULL)
 292                         UpdateChangedParamSet(subnode, node->ps.chgParam);
 293
 294                 /*
 295                  * If chgParam of subnode is not null then plan will be re-scanned by
 296                  * first ExecProcNode.
 297                  */
 298                 if (subnode->chgParam == NULL)
 299                         ExecReScan(subnode);
 300         }
 301         node->as_whichplan = 0;
 302         exec_append_initialize_next(node);
 303 }