#include "postgres.h"
#include "executor/executor.h"
#include "executor/nodeTableFuncscan.h"
#include "executor/tablefunc.h"
#include "miscadmin.h"
#include "nodes/execnodes.h"
#include "utils/builtins.h"
#include "utils/jsonpath.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/xml.h"

Include dependency graph for nodeTableFuncscan.c:

Functions
static TupleTableSlot *	TableFuncNext (TableFuncScanState *node)

static bool	TableFuncRecheck (TableFuncScanState node, TupleTableSlot slot)

static void	tfuncFetchRows (TableFuncScanState tstate, ExprContext econtext)

static void	tfuncInitialize (TableFuncScanState tstate, ExprContext econtext, Datum doc)

static void	tfuncLoadRows (TableFuncScanState tstate, ExprContext econtext)

static TupleTableSlot *	ExecTableFuncScan (PlanState *pstate)

TableFuncScanState *	ExecInitTableFuncScan (TableFuncScan node, EState estate, int eflags)

void	ExecEndTableFuncScan (TableFuncScanState *node)

void	ExecReScanTableFuncScan (TableFuncScanState *node)

Function Documentation

◆ ExecEndTableFuncScan()

void ExecEndTableFuncScan ( TableFuncScanState * node )

Definition at line 220 of file nodeTableFuncscan.c.

 {
     /*
      * Release tuplestore resources
      */
     if (node->tupstore != NULL)
         tuplestore_end(node->tupstore);
     node->tupstore = NULL;
 }

References tuplestore_end(), and TableFuncScanState::tupstore.

Referenced by ExecEndNode().

◆ ExecInitTableFuncScan()

TableFuncScanState* ExecInitTableFuncScan	(	TableFuncScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 111 of file nodeTableFuncscan.c.

 {
     TableFuncScanState *scanstate;
     TableFunc  *tf = node->tablefunc;
     TupleDesc   tupdesc;
     int         i;
  
     /* check for unsupported flags */
     Assert(!(eflags & EXEC_FLAG_MARK));
  
     /*
      * TableFuncscan should not have any children.
      */
     Assert(outerPlan(node) == NULL);
     Assert(innerPlan(node) == NULL);
  
     /*
      * create new ScanState for node
      */
     scanstate = makeNode(TableFuncScanState);
     scanstate->ss.ps.plan = (Plan *) node;
     scanstate->ss.ps.state = estate;
     scanstate->ss.ps.ExecProcNode = ExecTableFuncScan;
  
     /*
      * Miscellaneous initialization
      *
      * create expression context for node
      */
     ExecAssignExprContext(estate, &scanstate->ss.ps);
  
     /*
      * initialize source tuple type
      */
     tupdesc = BuildDescFromLists(tf->colnames,
                                  tf->coltypes,
                                  tf->coltypmods,
                                  tf->colcollations);
     /* and the corresponding scan slot */
     ExecInitScanTupleSlot(estate, &scanstate->ss, tupdesc,
                           &TTSOpsMinimalTuple);
  
     /*
      * Initialize result type and projection.
      */
     ExecInitResultTypeTL(&scanstate->ss.ps);
     ExecAssignScanProjectionInfo(&scanstate->ss);
  
     /*
      * initialize child expressions
      */
     scanstate->ss.ps.qual =
         ExecInitQual(node->scan.plan.qual, &scanstate->ss.ps);
  
     /* Only XMLTABLE and JSON_TABLE are supported currently */
     scanstate->routine =
         tf->functype == TFT_XMLTABLE ? &XmlTableRoutine : &JsonbTableRoutine;
  
     scanstate->perTableCxt =
         AllocSetContextCreate(CurrentMemoryContext,
                               "TableFunc per value context",
                               ALLOCSET_DEFAULT_SIZES);
     scanstate->opaque = NULL;   /* initialized at runtime */
  
     scanstate->ns_names = tf->ns_names;
  
     scanstate->ns_uris =
         ExecInitExprList(tf->ns_uris, (PlanState *) scanstate);
     scanstate->docexpr =
         ExecInitExpr((Expr *) tf->docexpr, (PlanState *) scanstate);
     scanstate->rowexpr =
         ExecInitExpr((Expr *) tf->rowexpr, (PlanState *) scanstate);
     scanstate->colexprs =
         ExecInitExprList(tf->colexprs, (PlanState *) scanstate);
     scanstate->coldefexprs =
         ExecInitExprList(tf->coldefexprs, (PlanState *) scanstate);
     scanstate->colvalexprs =
         ExecInitExprList(tf->colvalexprs, (PlanState *) scanstate);
     scanstate->passingvalexprs =
         ExecInitExprList(tf->passingvalexprs, (PlanState *) scanstate);
  
     scanstate->notnulls = tf->notnulls;
  
     /* these are allocated now and initialized later */
     scanstate->in_functions = palloc(sizeof(FmgrInfo) * tupdesc->natts);
     scanstate->typioparams = palloc(sizeof(Oid) * tupdesc->natts);
  
     /*
      * Fill in the necessary fmgr infos.
      */
     for (i = 0; i < tupdesc->natts; i++)
     {
         Oid         in_funcid;
  
         getTypeInputInfo(TupleDescAttr(tupdesc, i)->atttypid,
                          &in_funcid, &scanstate->typioparams[i]);
         fmgr_info(in_funcid, &scanstate->in_functions[i]);
     }
  
     return scanstate;
 }

Referenced by ExecInitNode().

◆ ExecReScanTableFuncScan()

void ExecReScanTableFuncScan ( TableFuncScanState * node )

Definition at line 237 of file nodeTableFuncscan.c.

 {
     Bitmapset  *chgparam = node->ss.ps.chgParam;
  
     if (node->ss.ps.ps_ResultTupleSlot)
         ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
     ExecScanReScan(&node->ss);
  
     /*
      * Recompute when parameters are changed.
      */
     if (chgparam)
     {
         if (node->tupstore != NULL)
         {
             tuplestore_end(node->tupstore);
             node->tupstore = NULL;
         }
     }
  
     if (node->tupstore != NULL)
         tuplestore_rescan(node->tupstore);
 }

References PlanState::chgParam, ExecClearTuple(), ExecScanReScan(), ScanState::ps, PlanState::ps_ResultTupleSlot, TableFuncScanState::ss, tuplestore_end(), tuplestore_rescan(), and TableFuncScanState::tupstore.

Referenced by ExecReScan().

◆ ExecTableFuncScan()

static TupleTableSlot* ExecTableFuncScan ( PlanState * pstate )

static

Definition at line 97 of file nodeTableFuncscan.c.

 {
     TableFuncScanState *node = castNode(TableFuncScanState, pstate);
  
     return ExecScan(&node->ss,
                     (ExecScanAccessMtd) TableFuncNext,
                     (ExecScanRecheckMtd) TableFuncRecheck);
 }

References castNode, ExecScan(), TableFuncScanState::ss, TableFuncNext(), and TableFuncRecheck().

Referenced by ExecInitTableFuncScan().

◆ TableFuncNext()

static TupleTableSlot * TableFuncNext ( TableFuncScanState * node )

static

Definition at line 54 of file nodeTableFuncscan.c.

 {
     TupleTableSlot *scanslot;
  
     scanslot = node->ss.ss_ScanTupleSlot;
  
     /*
      * If first time through, read all tuples from function and put them in a
      * tuplestore. Subsequent calls just fetch tuples from tuplestore.
      */
     if (node->tupstore == NULL)
         tfuncFetchRows(node, node->ss.ps.ps_ExprContext);
  
     /*
      * Get the next tuple from tuplestore.
      */
     (void) tuplestore_gettupleslot(node->tupstore,
                                    true,
                                    false,
                                    scanslot);
     return scanslot;
 }

References ScanState::ps, PlanState::ps_ExprContext, TableFuncScanState::ss, ScanState::ss_ScanTupleSlot, tfuncFetchRows(), tuplestore_gettupleslot(), and TableFuncScanState::tupstore.

Referenced by ExecTableFuncScan().

◆ TableFuncRecheck()

static bool TableFuncRecheck	(	TableFuncScanState *	node,
		TupleTableSlot *	slot
	)

static

Definition at line 81 of file nodeTableFuncscan.c.

 {
     /* nothing to check */
     return true;
 }

Referenced by ExecTableFuncScan().

◆ tfuncFetchRows()

static void tfuncFetchRows	(	TableFuncScanState *	tstate,
		ExprContext *	econtext
	)

static

Definition at line 268 of file nodeTableFuncscan.c.

 {
     const TableFuncRoutine *routine = tstate->routine;
     MemoryContext oldcxt;
     Datum       value;
     bool        isnull;
  
     Assert(tstate->opaque == NULL);
  
     /* build tuplestore for the result */
     oldcxt = MemoryContextSwitchTo(econtext->ecxt_per_query_memory);
     tstate->tupstore = tuplestore_begin_heap(false, false, work_mem);
  
     /*
      * Each call to fetch a new set of rows - of which there may be very many
      * if XMLTABLE or JSON_TABLE is being used in a lateral join - will
      * allocate a possibly substantial amount of memory, so we cannot use the
      * per-query context here. perTableCxt now serves the same function as
      * "argcontext" does in FunctionScan - a place to store per-one-call (i.e.
      * one result table) lifetime data (as opposed to per-query or
      * per-result-tuple).
      */
     MemoryContextSwitchTo(tstate->perTableCxt);
  
     PG_TRY();
     {
         routine->InitOpaque(tstate,
                             tstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor->natts);
  
         /*
          * If evaluating the document expression returns NULL, the table
          * expression is empty and we return immediately.
          */
         value = ExecEvalExpr(tstate->docexpr, econtext, &isnull);
  
         if (!isnull)
         {
             /* otherwise, pass the document value to the table builder */
             tfuncInitialize(tstate, econtext, value);
  
             /* initialize ordinality counter */
             tstate->ordinal = 1;
  
             /* Load all rows into the tuplestore, and we're done */
             tfuncLoadRows(tstate, econtext);
         }
     }
     PG_CATCH();
     {
         if (tstate->opaque != NULL)
             routine->DestroyOpaque(tstate);
         PG_RE_THROW();
     }
     PG_END_TRY();
  
     /* clean up and return to original memory context */
  
     if (tstate->opaque != NULL)
     {
         routine->DestroyOpaque(tstate);
         tstate->opaque = NULL;
     }
  
     MemoryContextSwitchTo(oldcxt);
     MemoryContextReset(tstate->perTableCxt);
 }

References Assert, TableFuncRoutine::DestroyOpaque, TableFuncScanState::docexpr, ExprContext::ecxt_per_query_memory, ExecEvalExpr(), TableFuncRoutine::InitOpaque, MemoryContextReset(), MemoryContextSwitchTo(), TupleDescData::natts, TableFuncScanState::opaque, TableFuncScanState::ordinal, TableFuncScanState::perTableCxt, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, TableFuncScanState::routine, TableFuncScanState::ss, ScanState::ss_ScanTupleSlot, tfuncInitialize(), tfuncLoadRows(), TupleTableSlot::tts_tupleDescriptor, tuplestore_begin_heap(), TableFuncScanState::tupstore, value, and work_mem.

Referenced by TableFuncNext().

◆ tfuncInitialize()

static void tfuncInitialize	(	TableFuncScanState *	tstate,
		ExprContext *	econtext,
		Datum	doc
	)

static

Definition at line 340 of file nodeTableFuncscan.c.

 {
     const TableFuncRoutine *routine = tstate->routine;
     TupleDesc   tupdesc;
     ListCell   *lc1,
                *lc2;
     bool        isnull;
     int         colno;
     Datum       value;
     int         ordinalitycol =
         ((TableFuncScan *) (tstate->ss.ps.plan))->tablefunc->ordinalitycol;
  
     /*
      * Install the document as a possibly-toasted Datum into the tablefunc
      * context.
      */
     routine->SetDocument(tstate, doc);
  
     /* Evaluate namespace specifications */
     forboth(lc1, tstate->ns_uris, lc2, tstate->ns_names)
     {
         ExprState  *expr = (ExprState *) lfirst(lc1);
         String     *ns_node = lfirst_node(String, lc2);
         char       *ns_uri;
         char       *ns_name;
  
         value = ExecEvalExpr((ExprState *) expr, econtext, &isnull);
         if (isnull)
             ereport(ERROR,
                     (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                      errmsg("namespace URI must not be null")));
         ns_uri = TextDatumGetCString(value);
  
         /* DEFAULT is passed down to SetNamespace as NULL */
         ns_name = ns_node ? strVal(ns_node) : NULL;
  
         routine->SetNamespace(tstate, ns_name, ns_uri);
     }
  
     /*
      * Install the row filter expression, if any, into the table builder
      * context.
      */
     if (routine->SetRowFilter)
     {
         value = ExecEvalExpr(tstate->rowexpr, econtext, &isnull);
         if (isnull)
             ereport(ERROR,
                     (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                      errmsg("row filter expression must not be null")));
  
         routine->SetRowFilter(tstate, TextDatumGetCString(value));
     }
  
     /*
      * Install the column filter expressions into the table builder context.
      * If an expression is given, use that; otherwise the column name itself
      * is the column filter.
      */
     colno = 0;
     tupdesc = tstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor;
     foreach(lc1, tstate->colexprs)
     {
         char       *colfilter;
         Form_pg_attribute att = TupleDescAttr(tupdesc, colno);
  
         if (colno != ordinalitycol)
         {
             ExprState  *colexpr = lfirst(lc1);
  
             if (colexpr != NULL)
             {
                 value = ExecEvalExpr(colexpr, econtext, &isnull);
                 if (isnull)
                     ereport(ERROR,
                             (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                              errmsg("column filter expression must not be null"),
                              errdetail("Filter for column \"%s\" is null.",
                                        NameStr(att->attname))));
                 colfilter = TextDatumGetCString(value);
             }
             else
                 colfilter = NameStr(att->attname);
  
             routine->SetColumnFilter(tstate, colfilter, colno);
         }
  
         colno++;
     }
 }

References TableFuncScanState::colexprs, ereport, errcode(), errdetail(), errmsg(), ERROR, ExecEvalExpr(), forboth, lfirst, lfirst_node, NameStr, TableFuncScanState::ns_names, TableFuncScanState::ns_uris, PlanState::plan, ScanState::ps, TableFuncScanState::routine, TableFuncScanState::rowexpr, TableFuncRoutine::SetColumnFilter, TableFuncRoutine::SetDocument, TableFuncRoutine::SetNamespace, TableFuncRoutine::SetRowFilter, TableFuncScanState::ss, ScanState::ss_ScanTupleSlot, strVal, TextDatumGetCString, TupleTableSlot::tts_tupleDescriptor, TupleDescAttr, and value.

Referenced by tfuncFetchRows().

◆ tfuncLoadRows()

static void tfuncLoadRows	(	TableFuncScanState *	tstate,
		ExprContext *	econtext
	)

static

Definition at line 435 of file nodeTableFuncscan.c.

 {
     const TableFuncRoutine *routine = tstate->routine;
     TupleTableSlot *slot = tstate->ss.ss_ScanTupleSlot;
     TupleDesc   tupdesc = slot->tts_tupleDescriptor;
     Datum      *values = slot->tts_values;
     bool       *nulls = slot->tts_isnull;
     int         natts = tupdesc->natts;
     MemoryContext oldcxt;
     int         ordinalitycol;
  
     ordinalitycol =
         ((TableFuncScan *) (tstate->ss.ps.plan))->tablefunc->ordinalitycol;
  
     /*
      * We need a short-lived memory context that we can clean up each time
      * around the loop, to avoid wasting space. Our default per-tuple context
      * is fine for the job, since we won't have used it for anything yet in
      * this tuple cycle.
      */
     oldcxt = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
  
     /*
      * Keep requesting rows from the table builder until there aren't any.
      */
     while (routine->FetchRow(tstate))
     {
         ListCell   *cell = list_head(tstate->coldefexprs);
         int         colno;
  
         CHECK_FOR_INTERRUPTS();
  
         ExecClearTuple(tstate->ss.ss_ScanTupleSlot);
  
         /*
          * Obtain the value of each column for this row, installing them into
          * the slot; then add the tuple to the tuplestore.
          */
         for (colno = 0; colno < natts; colno++)
         {
             Form_pg_attribute att = TupleDescAttr(tupdesc, colno);
  
             if (colno == ordinalitycol)
             {
                 /* Fast path for ordinality column */
                 values[colno] = Int32GetDatum(tstate->ordinal++);
                 nulls[colno] = false;
             }
             else
             {
                 bool        isnull;
  
                 values[colno] = routine->GetValue(tstate,
                                                   colno,
                                                   att->atttypid,
                                                   att->atttypmod,
                                                   &isnull);
  
                 /* No value?  Evaluate and apply the default, if any */
                 if (isnull && cell != NULL)
                 {
                     ExprState  *coldefexpr = (ExprState *) lfirst(cell);
  
                     if (coldefexpr != NULL)
                         values[colno] = ExecEvalExpr(coldefexpr, econtext,
                                                      &isnull);
                 }
  
                 /* Verify a possible NOT NULL constraint */
                 if (isnull && bms_is_member(colno, tstate->notnulls))
                     ereport(ERROR,
                             (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                              errmsg("null is not allowed in column \"%s\"",
                                     NameStr(att->attname))));
  
                 nulls[colno] = isnull;
             }
  
             /* advance list of default expressions */
             if (cell != NULL)
                 cell = lnext(tstate->coldefexprs, cell);
         }
  
         tuplestore_putvalues(tstate->tupstore, tupdesc, values, nulls);
  
         MemoryContextReset(econtext->ecxt_per_tuple_memory);
     }
  
     MemoryContextSwitchTo(oldcxt);
 }

References bms_is_member(), CHECK_FOR_INTERRUPTS, TableFuncScanState::coldefexprs, ExprContext::ecxt_per_tuple_memory, ereport, errcode(), errmsg(), ERROR, ExecClearTuple(), ExecEvalExpr(), TableFuncRoutine::FetchRow, TableFuncRoutine::GetValue, Int32GetDatum(), lfirst, list_head(), lnext(), MemoryContextReset(), MemoryContextSwitchTo(), NameStr, TupleDescData::natts, TableFuncScanState::notnulls, TableFuncScanState::ordinal, PlanState::plan, ScanState::ps, TableFuncScanState::routine, TableFuncScanState::ss, ScanState::ss_ScanTupleSlot, TupleTableSlot::tts_isnull, TupleTableSlot::tts_tupleDescriptor, TupleTableSlot::tts_values, TupleDescAttr, tuplestore_putvalues(), TableFuncScanState::tupstore, and values.

Referenced by tfuncFetchRows().

Functions

Function Documentation

◆ ExecEndTableFuncScan()

◆ ExecInitTableFuncScan()

◆ ExecReScanTableFuncScan()

◆ ExecTableFuncScan()

◆ TableFuncNext()

◆ TableFuncRecheck()

◆ tfuncFetchRows()

◆ tfuncInitialize()

◆ tfuncLoadRows()