nodeTableFuncscan.c File Reference

#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:

Go to the source code of this file.

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;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), BuildDescFromLists(), TableFuncScanState::coldefexprs, TableFuncScanState::colexprs, TableFunc::colexprs, TableFuncScanState::colvalexprs, CurrentMemoryContext, TableFuncScanState::docexpr, TableFunc::docexpr, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecInitExpr(), ExecInitExprList(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), PlanState::ExecProcNode, ExecTableFuncScan(), fmgr_info(), TableFunc::functype, getTypeInputInfo(), i, TableFuncScanState::in_functions, innerPlan, JsonbTableRoutine, makeNode, TupleDescData::natts, TableFuncScanState::notnulls, TableFuncScanState::ns_names, TableFuncScanState::ns_uris, TableFuncScanState::opaque, outerPlan, palloc(), TableFuncScanState::passingvalexprs, TableFuncScanState::perTableCxt, PlanState::plan, ScanState::ps, PlanState::qual, TableFuncScanState::routine, TableFuncScanState::rowexpr, TableFunc::rowexpr, TableFuncScan::scan, TableFuncScanState::ss, PlanState::state, TableFuncScan::tablefunc, TFT_XMLTABLE, TTSOpsMinimalTuple, TupleDescAttr(), TableFuncScanState::typioparams, and XmlTableRoutine.

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().