src/backend/executor/nodeCtescan.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * nodeCtescan.c
   4  *        routines to handle CteScan nodes.
   5  *
   6  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        src/backend/executor/nodeCtescan.c
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15
  16 #include "postgres.h"
  17
  18 #include "executor/executor.h"
  19 #include "executor/nodeCtescan.h"
  20 #include "miscadmin.h"
  21
  22 static TupleTableSlot *CteScanNext(CteScanState *node);
  23
  24 /* ----------------------------------------------------------------
  25  *              CteScanNext
  26  *
  27  *              This is a workhorse for ExecCteScan
  28  * ----------------------------------------------------------------
  29  */
  30 static TupleTableSlot *
  31 CteScanNext(CteScanState *node)
  32 {
  33         EState     *estate;
  34         ScanDirection dir;
  35         bool            forward;
  36         Tuplestorestate *tuplestorestate;
  37         bool            eof_tuplestore;
  38         TupleTableSlot *slot;
  39
  40         /*
  41          * get state info from node
  42          */
  43         estate = node->ss.ps.state;
  44         dir = estate->es_direction;
  45         forward = ScanDirectionIsForward(dir);
  46         tuplestorestate = node->leader->cte_table;
  47         tuplestore_select_read_pointer(tuplestorestate, node->readptr);
  48         slot = node->ss.ss_ScanTupleSlot;
  49
  50         /*
  51          * If we are not at the end of the tuplestore, or are going backwards, try
  52          * to fetch a tuple from tuplestore.
  53          */
  54         eof_tuplestore = tuplestore_ateof(tuplestorestate);
  55
  56         if (!forward && eof_tuplestore)
  57         {
  58                 if (!node->leader->eof_cte)
  59                 {
  60                         /*
  61                          * When reversing direction at tuplestore EOF, the first
  62                          * gettupleslot call will fetch the last-added tuple; but we want
  63                          * to return the one before that, if possible. So do an extra
  64                          * fetch.
  65                          */
  66                         if (!tuplestore_advance(tuplestorestate, forward))
  67                                 return NULL;    /* the tuplestore must be empty */
  68                 }
  69                 eof_tuplestore = false;
  70         }
  71
  72         /*
  73          * If we can fetch another tuple from the tuplestore, return it.
  74          *
  75          * Note: we have to use copy=true in the tuplestore_gettupleslot call,
  76          * because we are sharing the tuplestore with other nodes that might write
  77          * into the tuplestore before we get called again.
  78          */
  79         if (!eof_tuplestore)
  80         {
  81                 if (tuplestore_gettupleslot(tuplestorestate, forward, true, slot))
  82                         return slot;
  83                 if (forward)
  84                         eof_tuplestore = true;
  85         }
  86
  87         /*
  88          * If necessary, try to fetch another row from the CTE query.
  89          *
  90          * Note: the eof_cte state variable exists to short-circuit further calls
  91          * of the CTE plan.  It's not optional, unfortunately, because some plan
  92          * node types are not robust about being called again when they've already
  93          * returned NULL.
  94          */
  95         if (eof_tuplestore && !node->leader->eof_cte)
  96         {
  97                 TupleTableSlot *cteslot;
  98
  99                 /*
 100                  * We can only get here with forward==true, so no need to worry about
 101                  * which direction the subplan will go.
 102                  */
 103                 cteslot = ExecProcNode(node->cteplanstate);
 104                 if (TupIsNull(cteslot))
 105                 {
 106                         node->leader->eof_cte = true;
 107                         return NULL;
 108                 }
 109
 110                 /*
 111                  * There are corner cases where the subplan could change which
 112                  * tuplestore read pointer is active, so be sure to reselect ours
 113                  * before storing the tuple we got.
 114                  */
 115                 tuplestore_select_read_pointer(tuplestorestate, node->readptr);
 116
 117                 /*
 118                  * Append a copy of the returned tuple to tuplestore.  NOTE: because
 119                  * our read pointer is certainly in EOF state, its read position will
 120                  * move forward over the added tuple.  This is what we want.  Also,
 121                  * any other readers will *not* move past the new tuple, which is what
 122                  * they want.
 123                  */
 124                 tuplestore_puttupleslot(tuplestorestate, cteslot);
 125
 126                 /*
 127                  * We MUST copy the CTE query's output tuple into our own slot. This
 128                  * is because other CteScan nodes might advance the CTE query before
 129                  * we are called again, and our output tuple must stay stable over
 130                  * that.
 131                  */
 132                 return ExecCopySlot(slot, cteslot);
 133         }
 134
 135         /*
 136          * Nothing left ...
 137          */
 138         return ExecClearTuple(slot);
 139 }
 140
 141 /*
 142  * CteScanRecheck -- access method routine to recheck a tuple in EvalPlanQual
 143  */
 144 static bool
 145 CteScanRecheck(CteScanState *node, TupleTableSlot *slot)
 146 {
 147         /* nothing to check */
 148         return true;
 149 }
 150
 151 /* ----------------------------------------------------------------
 152  *              ExecCteScan(node)
 153  *
 154  *              Scans the CTE sequentially and returns the next qualifying tuple.
 155  *              We call the ExecScan() routine and pass it the appropriate
 156  *              access method functions.
 157  * ----------------------------------------------------------------
 158  */
 159 static TupleTableSlot *
 160 ExecCteScan(PlanState *pstate)
 161 {
 162         CteScanState *node = castNode(CteScanState, pstate);
 163
 164         return ExecScan(&node->ss,
 165                                         (ExecScanAccessMtd) CteScanNext,
 166                                         (ExecScanRecheckMtd) CteScanRecheck);
 167 }
 168
 169
 170 /* ----------------------------------------------------------------
 171  *              ExecInitCteScan
 172  * ----------------------------------------------------------------
 173  */
 174 CteScanState *
 175 ExecInitCteScan(CteScan *node, EState *estate, int eflags)
 176 {
 177         CteScanState *scanstate;
 178         ParamExecData *prmdata;
 179
 180         /* check for unsupported flags */
 181         Assert(!(eflags & EXEC_FLAG_MARK));
 182
 183         /*
 184          * For the moment we have to force the tuplestore to allow REWIND, because
 185          * we might be asked to rescan the CTE even though upper levels didn't
 186          * tell us to be prepared to do it efficiently.  Annoying, since this
 187          * prevents truncation of the tuplestore.  XXX FIXME
 188          *
 189          * Note: if we are in an EPQ recheck plan tree, it's likely that no access
 190          * to the tuplestore is needed at all, making this even more annoying.
 191          * It's not worth improving that as long as all the read pointers would
 192          * have REWIND anyway, but if we ever improve this logic then that aspect
 193          * should be considered too.
 194          */
 195         eflags |= EXEC_FLAG_REWIND;
 196
 197         /*
 198          * CteScan should not have any children.
 199          */
 200         Assert(outerPlan(node) == NULL);
 201         Assert(innerPlan(node) == NULL);
 202
 203         /*
 204          * create new CteScanState for node
 205          */
 206         scanstate = makeNode(CteScanState);
 207         scanstate->ss.ps.plan = (Plan *) node;
 208         scanstate->ss.ps.state = estate;
 209         scanstate->ss.ps.ExecProcNode = ExecCteScan;
 210         scanstate->eflags = eflags;
 211         scanstate->cte_table = NULL;
 212         scanstate->eof_cte = false;
 213
 214         /*
 215          * Find the already-initialized plan for the CTE query.
 216          */
 217         scanstate->cteplanstate = (PlanState *) list_nth(estate->es_subplanstates,
 218                                                                                                          node->ctePlanId - 1);
 219
 220         /*
 221          * The Param slot associated with the CTE query is used to hold a pointer
 222          * to the CteState of the first CteScan node that initializes for this
 223          * CTE.  This node will be the one that holds the shared state for all the
 224          * CTEs, particularly the shared tuplestore.
 225          */
 226         prmdata = &(estate->es_param_exec_vals[node->cteParam]);
 227         Assert(prmdata->execPlan == NULL);
 228         Assert(!prmdata->isnull);
 229         scanstate->leader = castNode(CteScanState, DatumGetPointer(prmdata->value));
 230         if (scanstate->leader == NULL)
 231         {
 232                 /* I am the leader */
 233                 prmdata->value = PointerGetDatum(scanstate);
 234                 scanstate->leader = scanstate;
 235                 scanstate->cte_table = tuplestore_begin_heap(true, false, work_mem);
 236                 tuplestore_set_eflags(scanstate->cte_table, scanstate->eflags);
 237                 scanstate->readptr = 0;
 238         }
 239         else
 240         {
 241                 /* Not the leader */
 242                 /* Create my own read pointer, and ensure it is at start */
 243                 scanstate->readptr =
 244                         tuplestore_alloc_read_pointer(scanstate->leader->cte_table,
 245                                                                                   scanstate->eflags);
 246                 tuplestore_select_read_pointer(scanstate->leader->cte_table,
 247                                                                            scanstate->readptr);
 248                 tuplestore_rescan(scanstate->leader->cte_table);
 249         }
 250
 251         /*
 252          * Miscellaneous initialization
 253          *
 254          * create expression context for node
 255          */
 256         ExecAssignExprContext(estate, &scanstate->ss.ps);
 257
 258         /*
 259          * The scan tuple type (ie, the rowtype we expect to find in the work
 260          * table) is the same as the result rowtype of the CTE query.
 261          */
 262         ExecInitScanTupleSlot(estate, &scanstate->ss,
 263                                                   ExecGetResultType(scanstate->cteplanstate),
 264                                                   &TTSOpsMinimalTuple);
 265
 266         /*
 267          * Initialize result type and projection.
 268          */
 269         ExecInitResultTypeTL(&scanstate->ss.ps);
 270         ExecAssignScanProjectionInfo(&scanstate->ss);
 271
 272         /*
 273          * initialize child expressions
 274          */
 275         scanstate->ss.ps.qual =
 276                 ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);
 277
 278         return scanstate;
 279 }
 280
 281 /* ----------------------------------------------------------------
 282  *              ExecEndCteScan
 283  *
 284  *              frees any storage allocated through C routines.
 285  * ----------------------------------------------------------------
 286  */
 287 void
 288 ExecEndCteScan(CteScanState *node)
 289 {
 290         /*
 291          * If I am the leader, free the tuplestore.
 292          */
 293         if (node->leader == node)
 294         {
 295                 tuplestore_end(node->cte_table);
 296                 node->cte_table = NULL;
 297         }
 298 }
 299
 300 /* ----------------------------------------------------------------
 301  *              ExecReScanCteScan
 302  *
 303  *              Rescans the relation.
 304  * ----------------------------------------------------------------
 305  */
 306 void
 307 ExecReScanCteScan(CteScanState *node)
 308 {
 309         Tuplestorestate *tuplestorestate = node->leader->cte_table;
 310
 311         if (node->ss.ps.ps_ResultTupleSlot)
 312                 ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 313
 314         ExecScanReScan(&node->ss);
 315
 316         /*
 317          * Clear the tuplestore if a new scan of the underlying CTE is required.
 318          * This implicitly resets all the tuplestore's read pointers.  Note that
 319          * multiple CTE nodes might redundantly clear the tuplestore; that's OK,
 320          * and not unduly expensive.  We'll stop taking this path as soon as
 321          * somebody has attempted to read something from the underlying CTE
 322          * (thereby causing its chgParam to be cleared).
 323          */
 324         if (node->leader->cteplanstate->chgParam != NULL)
 325         {
 326                 tuplestore_clear(tuplestorestate);
 327                 node->leader->eof_cte = false;
 328         }
 329         else
 330         {
 331                 /*
 332                  * Else, just rewind my own pointer.  Either the underlying CTE
 333                  * doesn't need a rescan (and we can re-read what's in the tuplestore
 334                  * now), or somebody else already took care of it.
 335                  */
 336                 tuplestore_select_read_pointer(tuplestorestate, node->readptr);
 337                 tuplestore_rescan(tuplestorestate);
 338         }
 339 }