#include "postgres.h"
#include "executor/executor.h"
#include "executor/nodeRecursiveunion.h"
#include "miscadmin.h"
#include "utils/memutils.h"

Include dependency graph for nodeRecursiveunion.c:

Functions
static void	build_hash_table (RecursiveUnionState *rustate)

static TupleTableSlot *	ExecRecursiveUnion (PlanState *pstate)

RecursiveUnionState *	ExecInitRecursiveUnion (RecursiveUnion node, EState estate, int eflags)

void	ExecEndRecursiveUnion (RecursiveUnionState *node)

void	ExecReScanRecursiveUnion (RecursiveUnionState *node)

Function Documentation

◆ build_hash_table()

static void build_hash_table ( RecursiveUnionState * rustate )

static

Definition at line 32 of file nodeRecursiveunion.c.

 {
     RecursiveUnion *node = (RecursiveUnion *) rustate->ps.plan;
     TupleDesc   desc = ExecGetResultType(outerPlanState(rustate));
  
     Assert(node->numCols > 0);
     Assert(node->numGroups > 0);
  
     rustate->hashtable = BuildTupleHashTableExt(&rustate->ps,
                                                 desc,
                                                 node->numCols,
                                                 node->dupColIdx,
                                                 rustate->eqfuncoids,
                                                 rustate->hashfunctions,
                                                 node->dupCollations,
                                                 node->numGroups,
                                                 0,
                                                 rustate->ps.state->es_query_cxt,
                                                 rustate->tableContext,
                                                 rustate->tempContext,
                                                 false);
 }

References Assert, BuildTupleHashTableExt(), RecursiveUnionState::eqfuncoids, EState::es_query_cxt, ExecGetResultType(), RecursiveUnionState::hashfunctions, RecursiveUnionState::hashtable, RecursiveUnion::numCols, RecursiveUnion::numGroups, outerPlanState, PlanState::plan, RecursiveUnionState::ps, PlanState::state, RecursiveUnionState::tableContext, and RecursiveUnionState::tempContext.

Referenced by ExecInitRecursiveUnion().

◆ ExecEndRecursiveUnion()

void ExecEndRecursiveUnion ( RecursiveUnionState * node )

Definition at line 272 of file nodeRecursiveunion.c.

 {
     /* Release tuplestores */
     tuplestore_end(node->working_table);
     tuplestore_end(node->intermediate_table);
  
     /* free subsidiary stuff including hashtable */
     if (node->tempContext)
         MemoryContextDelete(node->tempContext);
     if (node->tableContext)
         MemoryContextDelete(node->tableContext);
  
     /*
      * close down subplans
      */
     ExecEndNode(outerPlanState(node));
     ExecEndNode(innerPlanState(node));
 }

References ExecEndNode(), innerPlanState, RecursiveUnionState::intermediate_table, MemoryContextDelete(), outerPlanState, RecursiveUnionState::tableContext, RecursiveUnionState::tempContext, tuplestore_end(), and RecursiveUnionState::working_table.

Referenced by ExecEndNode().

◆ ExecInitRecursiveUnion()

RecursiveUnionState* ExecInitRecursiveUnion	(	RecursiveUnion *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 167 of file nodeRecursiveunion.c.

 {
     RecursiveUnionState *rustate;
     ParamExecData *prmdata;
  
     /* check for unsupported flags */
     Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
  
     /*
      * create state structure
      */
     rustate = makeNode(RecursiveUnionState);
     rustate->ps.plan = (Plan *) node;
     rustate->ps.state = estate;
     rustate->ps.ExecProcNode = ExecRecursiveUnion;
  
     rustate->eqfuncoids = NULL;
     rustate->hashfunctions = NULL;
     rustate->hashtable = NULL;
     rustate->tempContext = NULL;
     rustate->tableContext = NULL;
  
     /* initialize processing state */
     rustate->recursing = false;
     rustate->intermediate_empty = true;
     rustate->working_table = tuplestore_begin_heap(false, false, work_mem);
     rustate->intermediate_table = tuplestore_begin_heap(false, false, work_mem);
  
     /*
      * If hashing, we need a per-tuple memory context for comparisons, and a
      * longer-lived context to store the hash table.  The table can't just be
      * kept in the per-query context because we want to be able to throw it
      * away when rescanning.
      */
     if (node->numCols > 0)
     {
         rustate->tempContext =
             AllocSetContextCreate(CurrentMemoryContext,
                                   "RecursiveUnion",
                                   ALLOCSET_DEFAULT_SIZES);
         rustate->tableContext =
             AllocSetContextCreate(CurrentMemoryContext,
                                   "RecursiveUnion hash table",
                                   ALLOCSET_DEFAULT_SIZES);
     }
  
     /*
      * Make the state structure available to descendant WorkTableScan nodes
      * via the Param slot reserved for it.
      */
     prmdata = &(estate->es_param_exec_vals[node->wtParam]);
     Assert(prmdata->execPlan == NULL);
     prmdata->value = PointerGetDatum(rustate);
     prmdata->isnull = false;
  
     /*
      * Miscellaneous initialization
      *
      * RecursiveUnion plans don't have expression contexts because they never
      * call ExecQual or ExecProject.
      */
     Assert(node->plan.qual == NIL);
  
     /*
      * RecursiveUnion nodes still have Result slots, which hold pointers to
      * tuples, so we have to initialize them.
      */
     ExecInitResultTypeTL(&rustate->ps);
  
     /*
      * Initialize result tuple type.  (Note: we have to set up the result type
      * before initializing child nodes, because nodeWorktablescan.c expects it
      * to be valid.)
      */
     rustate->ps.ps_ProjInfo = NULL;
  
     /*
      * initialize child nodes
      */
     outerPlanState(rustate) = ExecInitNode(outerPlan(node), estate, eflags);
     innerPlanState(rustate) = ExecInitNode(innerPlan(node), estate, eflags);
  
     /*
      * If hashing, precompute fmgr lookup data for inner loop, and create the
      * hash table.
      */
     if (node->numCols > 0)
     {
         execTuplesHashPrepare(node->numCols,
                               node->dupOperators,
                               &rustate->eqfuncoids,
                               &rustate->hashfunctions);
         build_hash_table(rustate);
     }
  
     return rustate;
 }

Referenced by ExecInitNode().

◆ ExecRecursiveUnion()

static TupleTableSlot* ExecRecursiveUnion ( PlanState * pstate )

static

Definition at line 75 of file nodeRecursiveunion.c.

 {
     RecursiveUnionState *node = castNode(RecursiveUnionState, pstate);
     PlanState  *outerPlan = outerPlanState(node);
     PlanState  *innerPlan = innerPlanState(node);
     RecursiveUnion *plan = (RecursiveUnion *) node->ps.plan;
     TupleTableSlot *slot;
     bool        isnew;
  
     CHECK_FOR_INTERRUPTS();
  
     /* 1. Evaluate non-recursive term */
     if (!node->recursing)
     {
         for (;;)
         {
             slot = ExecProcNode(outerPlan);
             if (TupIsNull(slot))
                 break;
             if (plan->numCols > 0)
             {
                 /* Find or build hashtable entry for this tuple's group */
                 LookupTupleHashEntry(node->hashtable, slot, &isnew, NULL);
                 /* Must reset temp context after each hashtable lookup */
                 MemoryContextReset(node->tempContext);
                 /* Ignore tuple if already seen */
                 if (!isnew)
                     continue;
             }
             /* Each non-duplicate tuple goes to the working table ... */
             tuplestore_puttupleslot(node->working_table, slot);
             /* ... and to the caller */
             return slot;
         }
         node->recursing = true;
     }
  
     /* 2. Execute recursive term */
     for (;;)
     {
         slot = ExecProcNode(innerPlan);
         if (TupIsNull(slot))
         {
             /* Done if there's nothing in the intermediate table */
             if (node->intermediate_empty)
                 break;
  
             /* done with old working table ... */
             tuplestore_end(node->working_table);
  
             /* intermediate table becomes working table */
             node->working_table = node->intermediate_table;
  
             /* create new empty intermediate table */
             node->intermediate_table = tuplestore_begin_heap(false, false,
                                                              work_mem);
             node->intermediate_empty = true;
  
             /* reset the recursive term */
             innerPlan->chgParam = bms_add_member(innerPlan->chgParam,
                                                  plan->wtParam);
  
             /* and continue fetching from recursive term */
             continue;
         }
  
         if (plan->numCols > 0)
         {
             /* Find or build hashtable entry for this tuple's group */
             LookupTupleHashEntry(node->hashtable, slot, &isnew, NULL);
             /* Must reset temp context after each hashtable lookup */
             MemoryContextReset(node->tempContext);
             /* Ignore tuple if already seen */
             if (!isnew)
                 continue;
         }
  
         /* Else, tuple is good; stash it in intermediate table ... */
         node->intermediate_empty = false;
         tuplestore_puttupleslot(node->intermediate_table, slot);
         /* ... and return it */
         return slot;
     }
  
     return NULL;
 }

References bms_add_member(), castNode, CHECK_FOR_INTERRUPTS, ExecProcNode(), RecursiveUnionState::hashtable, innerPlan, innerPlanState, RecursiveUnionState::intermediate_empty, RecursiveUnionState::intermediate_table, LookupTupleHashEntry(), MemoryContextReset(), outerPlan, outerPlanState, PlanState::plan, plan, RecursiveUnionState::ps, RecursiveUnionState::recursing, RecursiveUnionState::tempContext, TupIsNull, tuplestore_begin_heap(), tuplestore_end(), tuplestore_puttupleslot(), work_mem, and RecursiveUnionState::working_table.

Referenced by ExecInitRecursiveUnion().

◆ ExecReScanRecursiveUnion()

void ExecReScanRecursiveUnion ( RecursiveUnionState * node )

Definition at line 298 of file nodeRecursiveunion.c.

 {
     PlanState  *outerPlan = outerPlanState(node);
     PlanState  *innerPlan = innerPlanState(node);
     RecursiveUnion *plan = (RecursiveUnion *) node->ps.plan;
  
     /*
      * Set recursive term's chgParam to tell it that we'll modify the working
      * table and therefore it has to rescan.
      */
     innerPlan->chgParam = bms_add_member(innerPlan->chgParam, plan->wtParam);
  
     /*
      * if chgParam of subnode is not null then plan will be re-scanned by
      * first ExecProcNode.  Because of above, we only have to do this to the
      * non-recursive term.
      */
     if (outerPlan->chgParam == NULL)
         ExecReScan(outerPlan);
  
     /* Release any hashtable storage */
     if (node->tableContext)
         MemoryContextReset(node->tableContext);
  
     /* Empty hashtable if needed */
     if (plan->numCols > 0)
         ResetTupleHashTable(node->hashtable);
  
     /* reset processing state */
     node->recursing = false;
     node->intermediate_empty = true;
     tuplestore_clear(node->working_table);
     tuplestore_clear(node->intermediate_table);
 }

References bms_add_member(), ExecReScan(), RecursiveUnionState::hashtable, innerPlan, innerPlanState, RecursiveUnionState::intermediate_empty, RecursiveUnionState::intermediate_table, MemoryContextReset(), outerPlan, outerPlanState, PlanState::plan, plan, RecursiveUnionState::ps, RecursiveUnionState::recursing, ResetTupleHashTable(), RecursiveUnionState::tableContext, tuplestore_clear(), and RecursiveUnionState::working_table.