execUtils.c File Reference

#include "postgres.h"
#include "access/parallel.h"
#include "access/relscan.h"
#include "access/table.h"
#include "access/tableam.h"
#include "access/transam.h"
#include "executor/executor.h"
#include "executor/execPartition.h"
#include "jit/jit.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "parser/parsetree.h"
#include "partitioning/partdesc.h"
#include "storage/lmgr.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/typcache.h"

Include dependency graph for execUtils.c:

Go to the source code of this file.

Functions
static bool	tlist_matches_tupdesc (PlanState *ps, List *tlist, int varno, TupleDesc tupdesc)
static void	ShutdownExprContext (ExprContext *econtext, bool isCommit)
EState *	CreateExecutorState (void)
void	FreeExecutorState (EState *estate)
static ExprContext *	CreateExprContextInternal (EState *estate, Size minContextSize, Size initBlockSize, Size maxBlockSize)
ExprContext *	CreateExprContext (EState *estate)
ExprContext *	CreateWorkExprContext (EState *estate)
ExprContext *	CreateStandaloneExprContext (void)
void	FreeExprContext (ExprContext *econtext, bool isCommit)
void	ReScanExprContext (ExprContext *econtext)
ExprContext *	MakePerTupleExprContext (EState *estate)
void	ExecAssignExprContext (EState *estate, PlanState *planstate)
TupleDesc	ExecGetResultType (PlanState *planstate)
const TupleTableSlotOps *	ExecGetResultSlotOps (PlanState *planstate, bool *isfixed)
void	ExecAssignProjectionInfo (PlanState *planstate, TupleDesc inputDesc)
void	ExecConditionalAssignProjectionInfo (PlanState *planstate, TupleDesc inputDesc, int varno)
void	ExecFreeExprContext (PlanState *planstate)
void	ExecAssignScanType (ScanState *scanstate, TupleDesc tupDesc)
void	ExecCreateScanSlotFromOuterPlan (EState *estate, ScanState *scanstate, const TupleTableSlotOps *tts_ops)
bool	ExecRelationIsTargetRelation (EState *estate, Index scanrelid)
Relation	ExecOpenScanRelation (EState *estate, Index scanrelid, int eflags)
void	ExecInitRangeTable (EState *estate, List *rangeTable)
Relation	ExecGetRangeTableRelation (EState *estate, Index rti)
void	ExecInitResultRelation (EState *estate, ResultRelInfo *resultRelInfo, Index rti)
void	UpdateChangedParamSet (PlanState *node, Bitmapset *newchg)
int	executor_errposition (EState *estate, int location)
void	RegisterExprContextCallback (ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)
void	UnregisterExprContextCallback (ExprContext *econtext, ExprContextCallbackFunction function, Datum arg)
Datum	GetAttributeByName (HeapTupleHeader tuple, const char *attname, bool *isNull)
Datum	GetAttributeByNum (HeapTupleHeader tuple, AttrNumber attrno, bool *isNull)
int	ExecTargetListLength (List *targetlist)
int	ExecCleanTargetListLength (List *targetlist)
TupleTableSlot *	ExecGetTriggerOldSlot (EState *estate, ResultRelInfo *relInfo)
TupleTableSlot *	ExecGetTriggerNewSlot (EState *estate, ResultRelInfo *relInfo)
TupleTableSlot *	ExecGetReturningSlot (EState *estate, ResultRelInfo *relInfo)
TupleConversionMap *	ExecGetChildToRootMap (ResultRelInfo *resultRelInfo)
Bitmapset *	ExecGetInsertedCols (ResultRelInfo *relinfo, EState *estate)
Bitmapset *	ExecGetUpdatedCols (ResultRelInfo *relinfo, EState *estate)
Bitmapset *	ExecGetExtraUpdatedCols (ResultRelInfo *relinfo, EState *estate)
Bitmapset *	ExecGetAllUpdatedCols (ResultRelInfo *relinfo, EState *estate)

Function Documentation

CreateExecutorState()

EState* CreateExecutorState

(

void

)

Definition at line 90 of file execUtils.c.

{
    EState     *estate;
    MemoryContext qcontext;
    MemoryContext oldcontext;
 
    /*
     * Create the per-query context for this Executor run.
     */
    qcontext = AllocSetContextCreate(CurrentMemoryContext,
                                     "ExecutorState",
                                     ALLOCSET_DEFAULT_SIZES);
 
    /*
     * Make the EState node within the per-query context.  This way, we don't
     * need a separate pfree() operation for it at shutdown.
     */
    oldcontext = MemoryContextSwitchTo(qcontext);
 
    estate = makeNode(EState);
 
    /*
     * Initialize all fields of the Executor State structure
     */
    estate->es_direction = ForwardScanDirection;
    estate->es_snapshot = InvalidSnapshot;  /* caller must initialize this */
    estate->es_crosscheck_snapshot = InvalidSnapshot;   /* no crosscheck */
    estate->es_range_table = NIL;
    estate->es_range_table_size = 0;
    estate->es_relations = NULL;
    estate->es_rowmarks = NULL;
    estate->es_plannedstmt = NULL;
 
    estate->es_junkFilter = NULL;
 
    estate->es_output_cid = (CommandId) 0;
 
    estate->es_result_relations = NULL;
    estate->es_opened_result_relations = NIL;
    estate->es_tuple_routing_result_relations = NIL;
    estate->es_trig_target_relations = NIL;
 
    estate->es_param_list_info = NULL;
    estate->es_param_exec_vals = NULL;
 
    estate->es_queryEnv = NULL;
 
    estate->es_query_cxt = qcontext;
 
    estate->es_tupleTable = NIL;
 
    estate->es_processed = 0;
 
    estate->es_top_eflags = 0;
    estate->es_instrument = 0;
    estate->es_finished = false;
 
    estate->es_exprcontexts = NIL;
 
    estate->es_subplanstates = NIL;
 
    estate->es_auxmodifytables = NIL;
 
    estate->es_per_tuple_exprcontext = NULL;
 
    estate->es_sourceText = NULL;
 
    estate->es_use_parallel_mode = false;
 
    estate->es_jit_flags = 0;
    estate->es_jit = NULL;
 
    /*
     * Return the executor state structure
     */
    MemoryContextSwitchTo(oldcontext);
 
    return estate;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CurrentMemoryContext, EState::es_auxmodifytables, EState::es_crosscheck_snapshot, EState::es_direction, EState::es_exprcontexts, EState::es_finished, EState::es_instrument, EState::es_jit, EState::es_jit_flags, EState::es_junkFilter, EState::es_opened_result_relations, EState::es_output_cid, EState::es_param_exec_vals, EState::es_param_list_info, EState::es_per_tuple_exprcontext, EState::es_plannedstmt, EState::es_processed, EState::es_query_cxt, EState::es_queryEnv, EState::es_range_table, EState::es_range_table_size, EState::es_relations, EState::es_result_relations, EState::es_rowmarks, EState::es_snapshot, EState::es_sourceText, EState::es_subplanstates, EState::es_top_eflags, EState::es_trig_target_relations, EState::es_tuple_routing_result_relations, EState::es_tupleTable, EState::es_use_parallel_mode, ForwardScanDirection, InvalidSnapshot, makeNode, MemoryContextSwitchTo(), and NIL.

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), check_default_partition_contents(), compute_expr_stats(), compute_index_stats(), CopyFrom(), create_edata_for_relation(), EvalPlanQualStart(), evaluate_expr(), ExecuteCallStmt(), ExecuteQuery(), ExecuteTruncateGuts(), ExplainExecuteQuery(), get_qual_for_range(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), make_build_data(), operator_predicate_proof(), plpgsql_create_econtext(), plpgsql_inline_handler(), standard_ExecutorStart(), StoreAttrDefault(), tuplesort_begin_cluster(), and validateDomainConstraint().

CreateExprContext()

ExprContext* CreateExprContext

(

EState *

estate

)

Definition at line 301 of file execUtils.c.

{
    return CreateExprContextInternal(estate, ALLOCSET_DEFAULT_SIZES);
}

References ALLOCSET_DEFAULT_SIZES, and CreateExprContextInternal().

Referenced by ExecAssignExprContext(), ExecInitMergeJoin(), ExecInitSubPlan(), ExecuteCallStmt(), MakePerTupleExprContext(), and plpgsql_create_econtext().

CreateExprContextInternal()

static ExprContext* CreateExprContextInternal ( EState *  estate, Size  minContextSize, Size  initBlockSize, Size  maxBlockSize  )

static

Definition at line 231 of file execUtils.c.

{
    ExprContext *econtext;
    MemoryContext oldcontext;
 
    /* Create the ExprContext node within the per-query memory context */
    oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
    econtext = makeNode(ExprContext);
 
    /* Initialize fields of ExprContext */
    econtext->ecxt_scantuple = NULL;
    econtext->ecxt_innertuple = NULL;
    econtext->ecxt_outertuple = NULL;
 
    econtext->ecxt_per_query_memory = estate->es_query_cxt;
 
    /*
     * Create working memory for expression evaluation in this context.
     */
    econtext->ecxt_per_tuple_memory =
        AllocSetContextCreate(estate->es_query_cxt,
                              "ExprContext",
                              minContextSize,
                              initBlockSize,
                              maxBlockSize);
 
    econtext->ecxt_param_exec_vals = estate->es_param_exec_vals;
    econtext->ecxt_param_list_info = estate->es_param_list_info;
 
    econtext->ecxt_aggvalues = NULL;
    econtext->ecxt_aggnulls = NULL;
 
    econtext->caseValue_datum = (Datum) 0;
    econtext->caseValue_isNull = true;
 
    econtext->domainValue_datum = (Datum) 0;
    econtext->domainValue_isNull = true;
 
    econtext->ecxt_estate = estate;
 
    econtext->ecxt_callbacks = NULL;
 
    /*
     * Link the ExprContext into the EState to ensure it is shut down when the
     * EState is freed.  Because we use lcons(), shutdowns will occur in
     * reverse order of creation, which may not be essential but can't hurt.
     */
    estate->es_exprcontexts = lcons(econtext, estate->es_exprcontexts);
 
    MemoryContextSwitchTo(oldcontext);
 
    return econtext;
}

References AllocSetContextCreate, ExprContext::caseValue_datum, ExprContext::caseValue_isNull, ExprContext::domainValue_datum, ExprContext::domainValue_isNull, ExprContext::ecxt_aggnulls, ExprContext::ecxt_aggvalues, ExprContext::ecxt_callbacks, ExprContext::ecxt_estate, ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, ExprContext::ecxt_param_exec_vals, ExprContext::ecxt_param_list_info, ExprContext::ecxt_per_query_memory, ExprContext::ecxt_per_tuple_memory, ExprContext::ecxt_scantuple, EState::es_exprcontexts, EState::es_param_exec_vals, EState::es_param_list_info, EState::es_query_cxt, lcons(), makeNode, and MemoryContextSwitchTo().

Referenced by CreateExprContext(), and CreateWorkExprContext().

CreateStandaloneExprContext()

ExprContext* CreateStandaloneExprContext

(

void

)

Definition at line 352 of file execUtils.c.

{
    ExprContext *econtext;
 
    /* Create the ExprContext node within the caller's memory context */
    econtext = makeNode(ExprContext);
 
    /* Initialize fields of ExprContext */
    econtext->ecxt_scantuple = NULL;
    econtext->ecxt_innertuple = NULL;
    econtext->ecxt_outertuple = NULL;
 
    econtext->ecxt_per_query_memory = CurrentMemoryContext;
 
    /*
     * Create working memory for expression evaluation in this context.
     */
    econtext->ecxt_per_tuple_memory =
        AllocSetContextCreate(CurrentMemoryContext,
                              "ExprContext",
                              ALLOCSET_DEFAULT_SIZES);
 
    econtext->ecxt_param_exec_vals = NULL;
    econtext->ecxt_param_list_info = NULL;
 
    econtext->ecxt_aggvalues = NULL;
    econtext->ecxt_aggnulls = NULL;
 
    econtext->caseValue_datum = (Datum) 0;
    econtext->caseValue_isNull = true;
 
    econtext->domainValue_datum = (Datum) 0;
    econtext->domainValue_isNull = true;
 
    econtext->ecxt_estate = NULL;
 
    econtext->ecxt_callbacks = NULL;
 
    return econtext;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, ExprContext::caseValue_datum, ExprContext::caseValue_isNull, CurrentMemoryContext, ExprContext::domainValue_datum, ExprContext::domainValue_isNull, ExprContext::ecxt_aggnulls, ExprContext::ecxt_aggvalues, ExprContext::ecxt_callbacks, ExprContext::ecxt_estate, ExprContext::ecxt_innertuple, ExprContext::ecxt_outertuple, ExprContext::ecxt_param_exec_vals, ExprContext::ecxt_param_list_info, ExprContext::ecxt_per_query_memory, ExprContext::ecxt_per_tuple_memory, ExprContext::ecxt_scantuple, and makeNode.

Referenced by BuildTupleHashTableExt(), domain_check_input(), and hypothetical_dense_rank_final().

CreateWorkExprContext()

ExprContext* CreateWorkExprContext

(

EState *

estate

)

Definition at line 316 of file execUtils.c.

{
    Size        minContextSize = ALLOCSET_DEFAULT_MINSIZE;
    Size        initBlockSize = ALLOCSET_DEFAULT_INITSIZE;
    Size        maxBlockSize = ALLOCSET_DEFAULT_MAXSIZE;
 
    /* choose the maxBlockSize to be no larger than 1/16 of work_mem */
    while (16 * maxBlockSize > work_mem * 1024L)
        maxBlockSize >>= 1;
 
    if (maxBlockSize < ALLOCSET_DEFAULT_INITSIZE)
        maxBlockSize = ALLOCSET_DEFAULT_INITSIZE;
 
    return CreateExprContextInternal(estate, minContextSize,
                                     initBlockSize, maxBlockSize);
}

References ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE, ALLOCSET_DEFAULT_MINSIZE, CreateExprContextInternal(), and work_mem.

Referenced by ExecInitAgg().

ExecAssignExprContext()

void ExecAssignExprContext	(	EState *	estate,
		PlanState *	planstate
	)

Definition at line 480 of file execUtils.c.

{
    planstate->ps_ExprContext = CreateExprContext(estate);
}

References CreateExprContext(), and PlanState::ps_ExprContext.

Referenced by ExecInitAgg(), ExecInitAppend(), ExecInitBitmapHeapScan(), ExecInitBitmapIndexScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitInsertProjection(), ExecInitLimit(), ExecInitMemoize(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitModifyTable(), ExecInitNamedTuplestoreScan(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitResult(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSetOp(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidRangeScan(), ExecInitTidScan(), ExecInitUnique(), ExecInitUpdateProjection(), ExecInitValuesScan(), ExecInitWindowAgg(), and ExecInitWorkTableScan().

ExecAssignProjectionInfo()

void ExecAssignProjectionInfo	(	PlanState *	planstate,
		TupleDesc	inputDesc
	)

Definition at line 535 of file execUtils.c.

{
    planstate->ps_ProjInfo =
        ExecBuildProjectionInfo(planstate->plan->targetlist,
                                planstate->ps_ExprContext,
                                planstate->ps_ResultTupleSlot,
                                planstate,
                                inputDesc);
}

References ExecBuildProjectionInfo(), PlanState::plan, PlanState::ps_ExprContext, PlanState::ps_ProjInfo, PlanState::ps_ResultTupleSlot, and Plan::targetlist.

Referenced by ExecConditionalAssignProjectionInfo(), ExecInitAgg(), ExecInitGroup(), ExecInitHashJoin(), ExecInitMergeJoin(), ExecInitNestLoop(), ExecInitResult(), and ExecInitWindowAgg().

ExecAssignScanType()

void ExecAssignScanType	(	ScanState *	scanstate,
		TupleDesc	tupDesc
	)

Definition at line 670 of file execUtils.c.

{
    TupleTableSlot *slot = scanstate->ss_ScanTupleSlot;
 
    ExecSetSlotDescriptor(slot, tupDesc);
}

References ExecSetSlotDescriptor(), and ScanState::ss_ScanTupleSlot.

Referenced by ExecWorkTableScan().

ExecCleanTargetListLength()

int ExecCleanTargetListLength

(

List *

targetlist

)

Definition at line 1147 of file execUtils.c.

{
    int         len = 0;
    ListCell   *tl;
 
    foreach(tl, targetlist)
    {
        TargetEntry *curTle = lfirst_node(TargetEntry, tl);
 
        if (!curTle->resjunk)
            len++;
    }
    return len;
}

References len, lfirst_node, and TargetEntry::resjunk.

Referenced by check_sql_fn_retval(), and ExecTypeFromTLInternal().

ExecConditionalAssignProjectionInfo()

void ExecConditionalAssignProjectionInfo	(	PlanState *	planstate,
		TupleDesc	inputDesc,
		int	varno
	)

Definition at line 555 of file execUtils.c.

{
    if (tlist_matches_tupdesc(planstate,
                              planstate->plan->targetlist,
                              varno,
                              inputDesc))
    {
        planstate->ps_ProjInfo = NULL;
        planstate->resultopsset = planstate->scanopsset;
        planstate->resultopsfixed = planstate->scanopsfixed;
        planstate->resultops = planstate->scanops;
    }
    else
    {
        if (!planstate->ps_ResultTupleSlot)
        {
            ExecInitResultSlot(planstate, &TTSOpsVirtual);
            planstate->resultops = &TTSOpsVirtual;
            planstate->resultopsfixed = true;
            planstate->resultopsset = true;
        }
        ExecAssignProjectionInfo(planstate, inputDesc);
    }
}

References ExecAssignProjectionInfo(), ExecInitResultSlot(), PlanState::plan, PlanState::ps_ProjInfo, PlanState::ps_ResultTupleSlot, PlanState::resultops, PlanState::resultopsfixed, PlanState::resultopsset, PlanState::scanops, PlanState::scanopsfixed, PlanState::scanopsset, Plan::targetlist, tlist_matches_tupdesc(), and TTSOpsVirtual.

Referenced by ExecAssignScanProjectionInfo(), ExecAssignScanProjectionInfoWithVarno(), ExecInitGather(), and ExecInitGatherMerge().

ExecCreateScanSlotFromOuterPlan()

void ExecCreateScanSlotFromOuterPlan	(	EState *	estate,
		ScanState *	scanstate,
		const TupleTableSlotOps *	tts_ops
	)

Definition at line 682 of file execUtils.c.

{
    PlanState  *outerPlan;
    TupleDesc   tupDesc;
 
    outerPlan = outerPlanState(scanstate);
    tupDesc = ExecGetResultType(outerPlan);
 
    ExecInitScanTupleSlot(estate, scanstate, tupDesc, tts_ops);
}

References ExecGetResultType(), ExecInitScanTupleSlot(), outerPlan, and outerPlanState.

Referenced by ExecInitAgg(), ExecInitGroup(), ExecInitIncrementalSort(), ExecInitMaterial(), ExecInitMemoize(), ExecInitSort(), and ExecInitWindowAgg().

ExecFreeExprContext()

void ExecFreeExprContext

(

PlanState *

planstate

)

Definition at line 650 of file execUtils.c.

{
    /*
     * Per above discussion, don't actually delete the ExprContext. We do
     * unlink it from the plan node, though.
     */
    planstate->ps_ExprContext = NULL;
}

References PlanState::ps_ExprContext.

Referenced by ExecEndAgg(), ExecEndBitmapHeapScan(), ExecEndCteScan(), ExecEndCustomScan(), ExecEndForeignScan(), ExecEndFunctionScan(), ExecEndGather(), ExecEndGatherMerge(), ExecEndGroup(), ExecEndHash(), ExecEndHashJoin(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), ExecEndLimit(), ExecEndMemoize(), ExecEndMergeJoin(), ExecEndModifyTable(), ExecEndNamedTuplestoreScan(), ExecEndNestLoop(), ExecEndProjectSet(), ExecEndResult(), ExecEndSampleScan(), ExecEndSeqScan(), ExecEndSetOp(), ExecEndSubqueryScan(), ExecEndTableFuncScan(), ExecEndTidRangeScan(), ExecEndTidScan(), ExecEndUnique(), ExecEndValuesScan(), ExecEndWindowAgg(), and ExecEndWorkTableScan().

ExecGetAllUpdatedCols()

Bitmapset* ExecGetAllUpdatedCols	(	ResultRelInfo *	relinfo,
		EState *	estate
	)

Definition at line 1347 of file execUtils.c.

{
    return bms_union(ExecGetUpdatedCols(relinfo, estate),
                     ExecGetExtraUpdatedCols(relinfo, estate));
}

References bms_union(), ExecGetExtraUpdatedCols(), and ExecGetUpdatedCols().

Referenced by ExecARUpdateTriggers(), ExecASUpdateTriggers(), ExecBRUpdateTriggers(), ExecBSUpdateTriggers(), and ExecUpdateLockMode().

ExecGetChildToRootMap()

TupleConversionMap* ExecGetChildToRootMap

(

ResultRelInfo *

resultRelInfo

)

Definition at line 1234 of file execUtils.c.

{
    /* If we didn't already do so, compute the map for this child. */
    if (!resultRelInfo->ri_ChildToRootMapValid)
    {
        ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
 
        if (rootRelInfo)
            resultRelInfo->ri_ChildToRootMap =
                convert_tuples_by_name(RelationGetDescr(resultRelInfo->ri_RelationDesc),
                                       RelationGetDescr(rootRelInfo->ri_RelationDesc));
        else                    /* this isn't a child result rel */
            resultRelInfo->ri_ChildToRootMap = NULL;
 
        resultRelInfo->ri_ChildToRootMapValid = true;
    }
 
    return resultRelInfo->ri_ChildToRootMap;
}

References convert_tuples_by_name(), RelationGetDescr, ResultRelInfo::ri_ChildToRootMap, ResultRelInfo::ri_ChildToRootMapValid, ResultRelInfo::ri_RelationDesc, and ResultRelInfo::ri_RootResultRelInfo.

Referenced by adjust_partition_colnos(), AfterTriggerSaveEvent(), and ExecCrossPartitionUpdate().

ExecGetExtraUpdatedCols()

Bitmapset* ExecGetExtraUpdatedCols	(	ResultRelInfo *	relinfo,
		EState *	estate
	)

Definition at line 1321 of file execUtils.c.

{
    /* see ExecGetInsertedCols() */
    if (relinfo->ri_RangeTableIndex != 0)
    {
        RangeTblEntry *rte = exec_rt_fetch(relinfo->ri_RangeTableIndex, estate);
 
        return rte->extraUpdatedCols;
    }
    else if (relinfo->ri_RootResultRelInfo)
    {
        ResultRelInfo *rootRelInfo = relinfo->ri_RootResultRelInfo;
        RangeTblEntry *rte = exec_rt_fetch(rootRelInfo->ri_RangeTableIndex, estate);
 
        if (relinfo->ri_RootToPartitionMap != NULL)
            return execute_attr_map_cols(relinfo->ri_RootToPartitionMap->attrMap,
                                         rte->extraUpdatedCols);
        else
            return rte->extraUpdatedCols;
    }
    else
        return NULL;
}

References TupleConversionMap::attrMap, exec_rt_fetch(), execute_attr_map_cols(), RangeTblEntry::extraUpdatedCols, ResultRelInfo::ri_RangeTableIndex, ResultRelInfo::ri_RootResultRelInfo, and ResultRelInfo::ri_RootToPartitionMap.

Referenced by ExecComputeStoredGenerated(), ExecGetAllUpdatedCols(), and index_unchanged_by_update().

ExecGetInsertedCols()

Bitmapset* ExecGetInsertedCols	(	ResultRelInfo *	relinfo,
		EState *	estate
	)

Definition at line 1256 of file execUtils.c.

{
    /*
     * The columns are stored in the range table entry.  If this ResultRelInfo
     * represents a partition routing target, and doesn't have an entry of its
     * own in the range table, fetch the parent's RTE and map the columns to
     * the order they are in the partition.
     */
    if (relinfo->ri_RangeTableIndex != 0)
    {
        RangeTblEntry *rte = exec_rt_fetch(relinfo->ri_RangeTableIndex, estate);
 
        return rte->insertedCols;
    }
    else if (relinfo->ri_RootResultRelInfo)
    {
        ResultRelInfo *rootRelInfo = relinfo->ri_RootResultRelInfo;
        RangeTblEntry *rte = exec_rt_fetch(rootRelInfo->ri_RangeTableIndex, estate);
 
        if (relinfo->ri_RootToPartitionMap != NULL)
            return execute_attr_map_cols(relinfo->ri_RootToPartitionMap->attrMap,
                                         rte->insertedCols);
        else
            return rte->insertedCols;
    }
    else
    {
        /*
         * The relation isn't in the range table and it isn't a partition
         * routing target.  This ResultRelInfo must've been created only for
         * firing triggers and the relation is not being inserted into.  (See
         * ExecGetTriggerResultRel.)
         */
        return NULL;
    }
}

References TupleConversionMap::attrMap, exec_rt_fetch(), execute_attr_map_cols(), RangeTblEntry::insertedCols, ResultRelInfo::ri_RangeTableIndex, ResultRelInfo::ri_RootResultRelInfo, and ResultRelInfo::ri_RootToPartitionMap.

Referenced by ExecConstraints(), ExecPartitionCheckEmitError(), and ExecWithCheckOptions().

ExecGetRangeTableRelation()

Relation ExecGetRangeTableRelation	(	EState *	estate,
		Index	rti
	)

Definition at line 782 of file execUtils.c.

{
    Relation    rel;
 
    Assert(rti > 0 && rti <= estate->es_range_table_size);
 
    rel = estate->es_relations[rti - 1];
    if (rel == NULL)
    {
        /* First time through, so open the relation */
        RangeTblEntry *rte = exec_rt_fetch(rti, estate);
 
        Assert(rte->rtekind == RTE_RELATION);
 
        if (!IsParallelWorker())
        {
            /*
             * In a normal query, we should already have the appropriate lock,
             * but verify that through an Assert.  Since there's already an
             * Assert inside table_open that insists on holding some lock, it
             * seems sufficient to check this only when rellockmode is higher
             * than the minimum.
             */
            rel = table_open(rte->relid, NoLock);
            Assert(rte->rellockmode == AccessShareLock ||
                   CheckRelationLockedByMe(rel, rte->rellockmode, false));
        }
        else
        {
            /*
             * If we are a parallel worker, we need to obtain our own local
             * lock on the relation.  This ensures sane behavior in case the
             * parent process exits before we do.
             */
            rel = table_open(rte->relid, rte->rellockmode);
        }
 
        estate->es_relations[rti - 1] = rel;
    }
 
    return rel;
}

References AccessShareLock, Assert(), CheckRelationLockedByMe(), EState::es_relations, exec_rt_fetch(), IsParallelWorker, NoLock, RangeTblEntry::relid, RangeTblEntry::rellockmode, RTE_RELATION, RangeTblEntry::rtekind, and table_open().

Referenced by ExecCreatePartitionPruneState(), ExecInitResultRelation(), ExecOpenScanRelation(), and InitPlan().

ExecGetResultSlotOps()

const TupleTableSlotOps* ExecGetResultSlotOps	(	PlanState *	planstate,
		bool *	isfixed
	)

Definition at line 499 of file execUtils.c.

{
    if (planstate->resultopsset && planstate->resultops)
    {
        if (isfixed)
            *isfixed = planstate->resultopsfixed;
        return planstate->resultops;
    }
 
    if (isfixed)
    {
        if (planstate->resultopsset)
            *isfixed = planstate->resultopsfixed;
        else if (planstate->ps_ResultTupleSlot)
            *isfixed = TTS_FIXED(planstate->ps_ResultTupleSlot);
        else
            *isfixed = false;
    }
 
    if (!planstate->ps_ResultTupleSlot)
        return &TTSOpsVirtual;
 
    return planstate->ps_ResultTupleSlot->tts_ops;
}

References PlanState::ps_ResultTupleSlot, PlanState::resultops, PlanState::resultopsfixed, PlanState::resultopsset, TTS_FIXED, TupleTableSlot::tts_ops, and TTSOpsVirtual.

Referenced by ExecComputeSlotInfo(), ExecInitAgg(), ExecInitGroup(), ExecInitHashJoin(), ExecInitLimit(), ExecInitLockRows(), ExecInitMergeJoin(), and ExecInitSubqueryScan().

ExecGetResultType()

TupleDesc ExecGetResultType

(

PlanState *

planstate

)

Definition at line 490 of file execUtils.c.

{
    return planstate->ps_ResultTupleDesc;
}

References PlanState::ps_ResultTupleDesc.

Referenced by build_hash_table(), ExecComputeSlotInfo(), ExecCreateScanSlotFromOuterPlan(), ExecIncrementalSort(), ExecInitCteScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHashJoin(), ExecInitIncrementalSort(), ExecInitLimit(), ExecInitMergeJoin(), ExecInitNestLoop(), ExecInitSetOp(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitUnique(), ExecSort(), ExecWorkTableScan(), initialize_phase(), InitPlan(), and switchToPresortedPrefixMode().

ExecGetReturningSlot()

TupleTableSlot* ExecGetReturningSlot	(	EState *	estate,
		ResultRelInfo *	relInfo
	)

Definition at line 1210 of file execUtils.c.

{
    if (relInfo->ri_ReturningSlot == NULL)
    {
        Relation    rel = relInfo->ri_RelationDesc;
        MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
        relInfo->ri_ReturningSlot =
            ExecInitExtraTupleSlot(estate,
                                   RelationGetDescr(rel),
                                   table_slot_callbacks(rel));
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    return relInfo->ri_ReturningSlot;
}

References EState::es_query_cxt, ExecInitExtraTupleSlot(), MemoryContextSwitchTo(), RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_ReturningSlot, and table_slot_callbacks().

Referenced by apply_returning_filter(), ExecDelete(), and ExecInsert().

ExecGetTriggerNewSlot()

TupleTableSlot* ExecGetTriggerNewSlot	(	EState *	estate,
		ResultRelInfo *	relInfo
	)

Definition at line 1188 of file execUtils.c.

{
    if (relInfo->ri_TrigNewSlot == NULL)
    {
        Relation    rel = relInfo->ri_RelationDesc;
        MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
        relInfo->ri_TrigNewSlot =
            ExecInitExtraTupleSlot(estate,
                                   RelationGetDescr(rel),
                                   table_slot_callbacks(rel));
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    return relInfo->ri_TrigNewSlot;
}

References EState::es_query_cxt, ExecInitExtraTupleSlot(), MemoryContextSwitchTo(), RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigNewSlot, and table_slot_callbacks().

Referenced by AfterTriggerExecute().

ExecGetTriggerOldSlot()

TupleTableSlot* ExecGetTriggerOldSlot	(	EState *	estate,
		ResultRelInfo *	relInfo
	)

Definition at line 1166 of file execUtils.c.

{
    if (relInfo->ri_TrigOldSlot == NULL)
    {
        Relation    rel = relInfo->ri_RelationDesc;
        MemoryContext oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
 
        relInfo->ri_TrigOldSlot =
            ExecInitExtraTupleSlot(estate,
                                   RelationGetDescr(rel),
                                   table_slot_callbacks(rel));
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    return relInfo->ri_TrigOldSlot;
}

References EState::es_query_cxt, ExecInitExtraTupleSlot(), MemoryContextSwitchTo(), RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigOldSlot, and table_slot_callbacks().

Referenced by AfterTriggerExecute(), ExecARDeleteTriggers(), ExecARUpdateTriggers(), ExecBRDeleteTriggers(), ExecBRUpdateTriggers(), ExecIRDeleteTriggers(), and ExecIRUpdateTriggers().

ExecGetUpdatedCols()

Bitmapset* ExecGetUpdatedCols	(	ResultRelInfo *	relinfo,
		EState *	estate
	)

Definition at line 1295 of file execUtils.c.

{
    /* see ExecGetInsertedCols() */
    if (relinfo->ri_RangeTableIndex != 0)
    {
        RangeTblEntry *rte = exec_rt_fetch(relinfo->ri_RangeTableIndex, estate);
 
        return rte->updatedCols;
    }
    else if (relinfo->ri_RootResultRelInfo)
    {
        ResultRelInfo *rootRelInfo = relinfo->ri_RootResultRelInfo;
        RangeTblEntry *rte = exec_rt_fetch(rootRelInfo->ri_RangeTableIndex, estate);
 
        if (relinfo->ri_RootToPartitionMap != NULL)
            return execute_attr_map_cols(relinfo->ri_RootToPartitionMap->attrMap,
                                         rte->updatedCols);
        else
            return rte->updatedCols;
    }
    else
        return NULL;
}

References TupleConversionMap::attrMap, exec_rt_fetch(), execute_attr_map_cols(), ResultRelInfo::ri_RangeTableIndex, ResultRelInfo::ri_RootResultRelInfo, ResultRelInfo::ri_RootToPartitionMap, and RangeTblEntry::updatedCols.

Referenced by ExecConstraints(), ExecGetAllUpdatedCols(), ExecPartitionCheckEmitError(), ExecWithCheckOptions(), and index_unchanged_by_update().

ExecInitRangeTable()

void ExecInitRangeTable	(	EState *	estate,
		List *	rangeTable
	)

Definition at line 751 of file execUtils.c.

{
    /* Remember the range table List as-is */
    estate->es_range_table = rangeTable;
 
    /* Set size of associated arrays */
    estate->es_range_table_size = list_length(rangeTable);
 
    /*
     * Allocate an array to store an open Relation corresponding to each
     * rangetable entry, and initialize entries to NULL.  Relations are opened
     * and stored here as needed.
     */
    estate->es_relations = (Relation *)
        palloc0(estate->es_range_table_size * sizeof(Relation));
 
    /*
     * es_result_relations and es_rowmarks are also parallel to
     * es_range_table, but are allocated only if needed.
     */
    estate->es_result_relations = NULL;
    estate->es_rowmarks = NULL;
}

References EState::es_range_table, EState::es_range_table_size, EState::es_relations, EState::es_result_relations, EState::es_rowmarks, list_length(), and palloc0().

Referenced by CopyFrom(), create_edata_for_relation(), and InitPlan().

ExecInitResultRelation()

void ExecInitResultRelation	(	EState *	estate,
		ResultRelInfo *	resultRelInfo,
		Index	rti
	)

Definition at line 834 of file execUtils.c.

{
    Relation    resultRelationDesc;
 
    resultRelationDesc = ExecGetRangeTableRelation(estate, rti);
    InitResultRelInfo(resultRelInfo,
                      resultRelationDesc,
                      rti,
                      NULL,
                      estate->es_instrument);
 
    if (estate->es_result_relations == NULL)
        estate->es_result_relations = (ResultRelInfo **)
            palloc0(estate->es_range_table_size * sizeof(ResultRelInfo *));
    estate->es_result_relations[rti - 1] = resultRelInfo;
 
    /*
     * Saving in the list allows to avoid needlessly traversing the whole
     * array when only a few of its entries are possibly non-NULL.
     */
    estate->es_opened_result_relations =
        lappend(estate->es_opened_result_relations, resultRelInfo);
}

References EState::es_instrument, EState::es_opened_result_relations, EState::es_range_table_size, EState::es_result_relations, ExecGetRangeTableRelation(), InitResultRelInfo(), lappend(), and palloc0().

Referenced by CopyFrom(), and ExecInitModifyTable().

ExecOpenScanRelation()

Relation ExecOpenScanRelation	(	EState *	estate,
		Index	scanrelid,
		int	eflags
	)

Definition at line 720 of file execUtils.c.

{
    Relation    rel;
 
    /* Open the relation. */
    rel = ExecGetRangeTableRelation(estate, scanrelid);
 
    /*
     * Complain if we're attempting a scan of an unscannable relation, except
     * when the query won't actually be run.  This is a slightly klugy place
     * to do this, perhaps, but there is no better place.
     */
    if ((eflags & (EXEC_FLAG_EXPLAIN_ONLY | EXEC_FLAG_WITH_NO_DATA)) == 0 &&
        !RelationIsScannable(rel))
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("materialized view \"%s\" has not been populated",
                        RelationGetRelationName(rel)),
                 errhint("Use the REFRESH MATERIALIZED VIEW command.")));
 
    return rel;
}

References ereport, errcode(), errhint(), errmsg(), ERROR, EXEC_FLAG_EXPLAIN_ONLY, EXEC_FLAG_WITH_NO_DATA, ExecGetRangeTableRelation(), RelationGetRelationName, and RelationIsScannable.

Referenced by ExecInitBitmapHeapScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitTidRangeScan(), ExecInitTidScan(), and postgresBeginDirectModify().

ExecRelationIsTargetRelation()

bool ExecRelationIsTargetRelation	(	EState *	estate,
		Index	scanrelid
	)

Definition at line 707 of file execUtils.c.

{
    return list_member_int(estate->es_plannedstmt->resultRelations, scanrelid);
}

References EState::es_plannedstmt, list_member_int(), and PlannedStmt::resultRelations.

ExecTargetListLength()

int ExecTargetListLength

(

List *

targetlist

)

Definition at line 1137 of file execUtils.c.

{
    /* This used to be more complex, but fjoins are dead */
    return list_length(targetlist);
}

References list_length().

Referenced by ExecTypeFromTLInternal().

executor_errposition()

int executor_errposition	(	EState *	estate,
		int	location
	)

Definition at line 898 of file execUtils.c.

{
    int         pos;
 
    /* No-op if location was not provided */
    if (location < 0)
        return 0;
    /* Can't do anything if source text is not available */
    if (estate == NULL || estate->es_sourceText == NULL)
        return 0;
    /* Convert offset to character number */
    pos = pg_mbstrlen_with_len(estate->es_sourceText, location) + 1;
    /* And pass it to the ereport mechanism */
    return errposition(pos);
}

References errposition(), EState::es_sourceText, and pg_mbstrlen_with_len().

Referenced by ExecInitFunc(), ExecInitSubscriptingRef(), and init_sexpr().

FreeExecutorState()

void FreeExecutorState

(

EState *

estate

)

Definition at line 186 of file execUtils.c.

{
    /*
     * Shut down and free any remaining ExprContexts.  We do this explicitly
     * to ensure that any remaining shutdown callbacks get called (since they
     * might need to release resources that aren't simply memory within the
     * per-query memory context).
     */
    while (estate->es_exprcontexts)
    {
        /*
         * XXX: seems there ought to be a faster way to implement this than
         * repeated list_delete(), no?
         */
        FreeExprContext((ExprContext *) linitial(estate->es_exprcontexts),
                        true);
        /* FreeExprContext removed the list link for us */
    }
 
    /* release JIT context, if allocated */
    if (estate->es_jit)
    {
        jit_release_context(estate->es_jit);
        estate->es_jit = NULL;
    }
 
    /* release partition directory, if allocated */
    if (estate->es_partition_directory)
    {
        DestroyPartitionDirectory(estate->es_partition_directory);
        estate->es_partition_directory = NULL;
    }
 
    /*
     * Free the per-query memory context, thereby releasing all working
     * memory, including the EState node itself.
     */
    MemoryContextDelete(estate->es_query_cxt);
}

References DestroyPartitionDirectory(), EState::es_exprcontexts, EState::es_jit, EState::es_partition_directory, EState::es_query_cxt, FreeExprContext(), jit_release_context(), linitial, and MemoryContextDelete().

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), check_default_partition_contents(), compute_expr_stats(), compute_index_stats(), CopyFrom(), EvalPlanQualEnd(), evaluate_expr(), ExecuteCallStmt(), ExecuteQuery(), ExecuteTruncateGuts(), ExplainExecuteQuery(), finish_edata(), get_qual_for_range(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), make_build_data(), operator_predicate_proof(), plpgsql_inline_handler(), plpgsql_xact_cb(), standard_ExecutorEnd(), StoreAttrDefault(), tuplesort_free(), and validateDomainConstraint().

FreeExprContext()

void FreeExprContext	(	ExprContext *	econtext,
		bool	isCommit
	)

Definition at line 411 of file execUtils.c.

{
    EState     *estate;
 
    /* Call any registered callbacks */
    ShutdownExprContext(econtext, isCommit);
    /* And clean up the memory used */
    MemoryContextDelete(econtext->ecxt_per_tuple_memory);
    /* Unlink self from owning EState, if any */
    estate = econtext->ecxt_estate;
    if (estate)
        estate->es_exprcontexts = list_delete_ptr(estate->es_exprcontexts,
                                                  econtext);
    /* And delete the ExprContext node */
    pfree(econtext);
}

References ExprContext::ecxt_estate, ExprContext::ecxt_per_tuple_memory, EState::es_exprcontexts, list_delete_ptr(), MemoryContextDelete(), pfree(), and ShutdownExprContext().

Referenced by ExecEndBitmapIndexScan(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), FreeExecutorState(), plpgsql_destroy_econtext(), and plpgsql_subxact_cb().

GetAttributeByName()

Datum GetAttributeByName	(	HeapTupleHeader	tuple,
		const char *	attname,
		bool *	isNull
	)

Definition at line 1023 of file execUtils.c.

{
    AttrNumber  attrno;
    Datum       result;
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupDesc;
    HeapTupleData tmptup;
    int         i;
 
    if (attname == NULL)
        elog(ERROR, "invalid attribute name");
 
    if (isNull == NULL)
        elog(ERROR, "a NULL isNull pointer was passed");
 
    if (tuple == NULL)
    {
        /* Kinda bogus but compatible with old behavior... */
        *isNull = true;
        return (Datum) 0;
    }
 
    tupType = HeapTupleHeaderGetTypeId(tuple);
    tupTypmod = HeapTupleHeaderGetTypMod(tuple);
    tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
 
    attrno = InvalidAttrNumber;
    for (i = 0; i < tupDesc->natts; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupDesc, i);
 
        if (namestrcmp(&(att->attname), attname) == 0)
        {
            attrno = att->attnum;
            break;
        }
    }
 
    if (attrno == InvalidAttrNumber)
        elog(ERROR, "attribute \"%s\" does not exist", attname);
 
    /*
     * heap_getattr needs a HeapTuple not a bare HeapTupleHeader.  We set all
     * the fields in the struct just in case user tries to inspect system
     * columns.
     */
    tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
    ItemPointerSetInvalid(&(tmptup.t_self));
    tmptup.t_tableOid = InvalidOid;
    tmptup.t_data = tuple;
 
    result = heap_getattr(&tmptup,
                          attrno,
                          tupDesc,
                          isNull);
 
    ReleaseTupleDesc(tupDesc);
 
    return result;
}

References attname, elog, ERROR, heap_getattr, HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, i, InvalidAttrNumber, InvalidOid, ItemPointerSetInvalid, lookup_rowtype_tupdesc(), namestrcmp(), TupleDescData::natts, ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, HeapTupleData::t_tableOid, and TupleDescAttr.

Referenced by c_overpaid(), and overpaid().

GetAttributeByNum()

Datum GetAttributeByNum	(	HeapTupleHeader	tuple,
		AttrNumber	attrno,
		bool *	isNull
	)

Definition at line 1086 of file execUtils.c.

{
    Datum       result;
    Oid         tupType;
    int32       tupTypmod;
    TupleDesc   tupDesc;
    HeapTupleData tmptup;
 
    if (!AttributeNumberIsValid(attrno))
        elog(ERROR, "invalid attribute number %d", attrno);
 
    if (isNull == NULL)
        elog(ERROR, "a NULL isNull pointer was passed");
 
    if (tuple == NULL)
    {
        /* Kinda bogus but compatible with old behavior... */
        *isNull = true;
        return (Datum) 0;
    }
 
    tupType = HeapTupleHeaderGetTypeId(tuple);
    tupTypmod = HeapTupleHeaderGetTypMod(tuple);
    tupDesc = lookup_rowtype_tupdesc(tupType, tupTypmod);
 
    /*
     * heap_getattr needs a HeapTuple not a bare HeapTupleHeader.  We set all
     * the fields in the struct just in case user tries to inspect system
     * columns.
     */
    tmptup.t_len = HeapTupleHeaderGetDatumLength(tuple);
    ItemPointerSetInvalid(&(tmptup.t_self));
    tmptup.t_tableOid = InvalidOid;
    tmptup.t_data = tuple;
 
    result = heap_getattr(&tmptup,
                          attrno,
                          tupDesc,
                          isNull);
 
    ReleaseTupleDesc(tupDesc);
 
    return result;
}

References AttributeNumberIsValid, elog, ERROR, heap_getattr, HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, InvalidOid, ItemPointerSetInvalid, lookup_rowtype_tupdesc(), ReleaseTupleDesc, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

MakePerTupleExprContext()

ExprContext* MakePerTupleExprContext

(

EState *

estate

)

Definition at line 453 of file execUtils.c.

{
    if (estate->es_per_tuple_exprcontext == NULL)
        estate->es_per_tuple_exprcontext = CreateExprContext(estate);
 
    return estate->es_per_tuple_exprcontext;
}

References CreateExprContext(), and EState::es_per_tuple_exprcontext.

RegisterExprContextCallback()

void RegisterExprContextCallback	(	ExprContext *	econtext,
		ExprContextCallbackFunction	function,
		Datum	arg
	)

Definition at line 925 of file execUtils.c.

{
    ExprContext_CB *ecxt_callback;
 
    /* Save the info in appropriate memory context */
    ecxt_callback = (ExprContext_CB *)
        MemoryContextAlloc(econtext->ecxt_per_query_memory,
                           sizeof(ExprContext_CB));
 
    ecxt_callback->function = function;
    ecxt_callback->arg = arg;
 
    /* link to front of list for appropriate execution order */
    ecxt_callback->next = econtext->ecxt_callbacks;
    econtext->ecxt_callbacks = ecxt_callback;
}

References arg, ExprContext_CB::arg, ExprContext::ecxt_callbacks, ExprContext::ecxt_per_query_memory, ExprContext_CB::function, MemoryContextAlloc(), and ExprContext_CB::next.

Referenced by AggRegisterCallback(), ExecMakeFunctionResultSet(), ExecPrepareTuplestoreResult(), fmgr_sql(), and init_MultiFuncCall().

ReScanExprContext()

void ReScanExprContext

(

ExprContext *

econtext

)

Definition at line 438 of file execUtils.c.

{
    /* Call any registered callbacks */
    ShutdownExprContext(econtext, true);
    /* And clean up the memory used */
    MemoryContextReset(econtext->ecxt_per_tuple_memory);
}

References ExprContext::ecxt_per_tuple_memory, MemoryContextReset(), and ShutdownExprContext().

Referenced by agg_refill_hash_table(), agg_retrieve_direct(), domain_check_input(), ExecEndAgg(), ExecReScan(), ExecReScanAgg(), and ValuesNext().

ShutdownExprContext()

static void ShutdownExprContext ( ExprContext *  econtext, bool  isCommit  )

static

Definition at line 982 of file execUtils.c.

{
    ExprContext_CB *ecxt_callback;
    MemoryContext oldcontext;
 
    /* Fast path in normal case where there's nothing to do. */
    if (econtext->ecxt_callbacks == NULL)
        return;
 
    /*
     * Call the callbacks in econtext's per-tuple context.  This ensures that
     * any memory they might leak will get cleaned up.
     */
    oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
 
    /*
     * Call each callback function in reverse registration order.
     */
    while ((ecxt_callback = econtext->ecxt_callbacks) != NULL)
    {
        econtext->ecxt_callbacks = ecxt_callback->next;
        if (isCommit)
            ecxt_callback->function(ecxt_callback->arg);
        pfree(ecxt_callback);
    }
 
    MemoryContextSwitchTo(oldcontext);
}

References ExprContext_CB::arg, ExprContext::ecxt_callbacks, ExprContext::ecxt_per_tuple_memory, ExprContext_CB::function, MemoryContextSwitchTo(), ExprContext_CB::next, and pfree().

Referenced by FreeExprContext(), and ReScanExprContext().

tlist_matches_tupdesc()

static bool tlist_matches_tupdesc ( PlanState *  ps, List *  tlist, int  varno, TupleDesc  tupdesc  )

static

Definition at line 582 of file execUtils.c.

{
    int         numattrs = tupdesc->natts;
    int         attrno;
    ListCell   *tlist_item = list_head(tlist);
 
    /* Check the tlist attributes */
    for (attrno = 1; attrno <= numattrs; attrno++)
    {
        Form_pg_attribute att_tup = TupleDescAttr(tupdesc, attrno - 1);
        Var        *var;
 
        if (tlist_item == NULL)
            return false;       /* tlist too short */
        var = (Var *) ((TargetEntry *) lfirst(tlist_item))->expr;
        if (!var || !IsA(var, Var))
            return false;       /* tlist item not a Var */
        /* if these Asserts fail, planner messed up */
        Assert(var->varno == varno);
        Assert(var->varlevelsup == 0);
        if (var->varattno != attrno)
            return false;       /* out of order */
        if (att_tup->attisdropped)
            return false;       /* table contains dropped columns */
        if (att_tup->atthasmissing)
            return false;       /* table contains cols with missing values */
 
        /*
         * Note: usually the Var's type should match the tupdesc exactly, but
         * in situations involving unions of columns that have different
         * typmods, the Var may have come from above the union and hence have
         * typmod -1.  This is a legitimate situation since the Var still
         * describes the column, just not as exactly as the tupdesc does. We
         * could change the planner to prevent it, but it'd then insert
         * projection steps just to convert from specific typmod to typmod -1,
         * which is pretty silly.
         */
        if (var->vartype != att_tup->atttypid ||
            (var->vartypmod != att_tup->atttypmod &&
             var->vartypmod != -1))
            return false;       /* type mismatch */
 
        tlist_item = lnext(tlist, tlist_item);
    }
 
    if (tlist_item)
        return false;           /* tlist too long */
 
    return true;
}

References Assert(), IsA, lfirst, list_head(), lnext(), TupleDescData::natts, TupleDescAttr, Var::varattno, Var::varlevelsup, Var::varno, Var::vartype, and Var::vartypmod.

Referenced by ExecConditionalAssignProjectionInfo().

UnregisterExprContextCallback()

void UnregisterExprContextCallback	(	ExprContext *	econtext,
		ExprContextCallbackFunction	function,
		Datum	arg
	)

Definition at line 951 of file execUtils.c.

{
    ExprContext_CB **prev_callback;
    ExprContext_CB *ecxt_callback;
 
    prev_callback = &econtext->ecxt_callbacks;
 
    while ((ecxt_callback = *prev_callback) != NULL)
    {
        if (ecxt_callback->function == function && ecxt_callback->arg == arg)
        {
            *prev_callback = ecxt_callback->next;
            pfree(ecxt_callback);
        }
        else
            prev_callback = &ecxt_callback->next;
    }
}

References arg, ExprContext_CB::arg, ExprContext::ecxt_callbacks, ExprContext_CB::function, ExprContext_CB::next, and pfree().

Referenced by end_MultiFuncCall(), and fmgr_sql().

UpdateChangedParamSet()

void UpdateChangedParamSet	(	PlanState *	node,
		Bitmapset *	newchg
	)

Definition at line 864 of file execUtils.c.

{
    Bitmapset  *parmset;
 
    /*
     * The plan node only depends on params listed in its allParam set. Don't
     * include anything else into its chgParam set.
     */
    parmset = bms_intersect(node->plan->allParam, newchg);
 
    /*
     * Keep node->chgParam == NULL if there's not actually any members; this
     * allows the simplest possible tests in executor node files.
     */
    if (!bms_is_empty(parmset))
        node->chgParam = bms_join(node->chgParam, parmset);
    else
        bms_free(parmset);
}

References Plan::allParam, bms_free(), bms_intersect(), bms_is_empty(), bms_join(), PlanState::chgParam, and PlanState::plan.

Referenced by ExecReScan(), ExecReScanAppend(), ExecReScanBitmapAnd(), ExecReScanBitmapOr(), ExecReScanMergeAppend(), and ExecReScanSubqueryScan().