#include "postgres.h"
#include "access/parallel.h"
#include "access/table.h"
#include "access/tableam.h"
#include "access/tupconvert.h"
#include "executor/executor.h"
#include "executor/nodeModifyTable.h"
#include "jit/jit.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "parser/parse_relation.h"
#include "partitioning/partdesc.h"
#include "port/pg_bitutils.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:

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

static void	ShutdownExprContext (ExprContext *econtext, bool isCommit)

static RTEPermissionInfo *	GetResultRTEPermissionInfo (ResultRelInfo relinfo, EState estate)

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)

const TupleTableSlotOps *	ExecGetCommonSlotOps (PlanState **planstates, int nplans)

const TupleTableSlotOps *	ExecGetCommonChildSlotOps (PlanState *ps)

void	ExecAssignProjectionInfo (PlanState *planstate, TupleDesc inputDesc)

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

void	ExecAssignScanType (ScanState *scanstate, TupleDesc tupDesc)

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

bool	ExecRelationIsTargetRelation (EState *estate, Index scanrelid)

bool	ScanRelIsReadOnly (ScanState *ss)

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

void	ExecInitRangeTable (EState estate, List rangeTable, List permInfos, Bitmapset unpruned_relids)

Relation	ExecGetRangeTableRelation (EState *estate, Index rti, bool isResultRel)

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)

TupleTableSlot *	ExecGetAllNullSlot (EState estate, ResultRelInfo relInfo)

TupleConversionMap *	ExecGetChildToRootMap (ResultRelInfo *resultRelInfo)

TupleConversionMap *	ExecGetRootToChildMap (ResultRelInfo resultRelInfo, EState estate)

Bitmapset *	ExecGetInsertedCols (ResultRelInfo relinfo, EState estate)

Bitmapset *	ExecGetUpdatedCols (ResultRelInfo relinfo, EState estate)

Bitmapset *	ExecGetExtraUpdatedCols (ResultRelInfo relinfo, EState estate)

Bitmapset *	ExecGetAllUpdatedCols (ResultRelInfo relinfo, EState estate)

Oid	ExecGetResultRelCheckAsUser (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_rteperminfos = NIL;
    estate->es_plannedstmt = NULL;
    estate->es_part_prune_infos = NIL;
    estate->es_part_prune_states = NIL;
    estate->es_part_prune_results = NIL;
    estate->es_unpruned_relids = 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_insert_pending_result_relations = NIL;
    estate->es_insert_pending_modifytables = 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_total_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_parallel_workers_to_launch = 0;
    estate->es_parallel_workers_launched = 0;
 
    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_insert_pending_modifytables, EState::es_insert_pending_result_relations, EState::es_instrument, EState::es_jit, EState::es_jit_flags, EState::es_junkFilter, EState::es_opened_result_relations, EState::es_output_cid, EState::es_parallel_workers_launched, EState::es_parallel_workers_to_launch, EState::es_param_exec_vals, EState::es_param_list_info, EState::es_part_prune_infos, EState::es_part_prune_results, EState::es_part_prune_states, 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_rteperminfos, EState::es_snapshot, EState::es_sourceText, EState::es_subplanstates, EState::es_top_eflags, EState::es_total_processed, EState::es_trig_target_relations, EState::es_tuple_routing_result_relations, EState::es_tupleTable, EState::es_unpruned_relids, EState::es_use_parallel_mode, fb(), ForwardScanDirection, InvalidSnapshot, makeNode, MemoryContextSwitchTo(), and NIL.

Referenced by afterTriggerInvokeEvents(), ATExecAddColumn(), ATRewriteTable(), check_default_partition_contents(), compute_expr_stats(), compute_index_stats(), CopyFrom(), create_edata_for_relation(), create_estate_for_relation(), EvalPlanQualStart(), evaluate_expr(), ExecuteCallStmt(), ExecuteQuery(), ExecuteTruncateGuts(), ExplainExecuteQuery(), fileIterateForeignScan(), get_qual_for_range(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), initialize_change_context(), make_build_data(), MergePartitionsMoveRows(), operator_predicate_proof(), plpgsql_create_econtext(), plpgsql_inline_handler(), SplitPartitionMoveRows(), standard_ExecutorStart(), tuplesort_begin_cluster(), unique_key_recheck(), and validateDomainCheckConstraint().

◆ CreateExprContext()

ExprContext * CreateExprContext ( EState * estate )

Definition at line 312 of file execUtils.c.

{
    return CreateExprContextInternal(estate, ALLOCSET_DEFAULT_SIZES);
}

References ALLOCSET_DEFAULT_SIZES, and CreateExprContextInternal().

Referenced by CreatePartitionPruneState(), 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 242 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;
}

Referenced by CreateExprContext(), and CreateWorkExprContext().

◆ CreateStandaloneExprContext()

ExprContext * CreateStandaloneExprContext ( void )

Definition at line 362 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, fb(), and makeNode.

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

◆ CreateWorkExprContext()

ExprContext * CreateWorkExprContext ( EState * estate )

Definition at line 327 of file execUtils.c.

{
    Size        maxBlockSize;
 
    maxBlockSize = pg_prevpower2_size_t(work_mem * (Size) 1024 / 16);
 
    /* But no bigger than ALLOCSET_DEFAULT_MAXSIZE */
    maxBlockSize = Min(maxBlockSize, ALLOCSET_DEFAULT_MAXSIZE);
 
    /* and no smaller than ALLOCSET_DEFAULT_INITSIZE */
    maxBlockSize = Max(maxBlockSize, ALLOCSET_DEFAULT_INITSIZE);
 
    return CreateExprContextInternal(estate, ALLOCSET_DEFAULT_MINSIZE,
                                     ALLOCSET_DEFAULT_INITSIZE, maxBlockSize);
}

References ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE, ALLOCSET_DEFAULT_MINSIZE, CreateExprContextInternal(), Max, Min, pg_prevpower2_size_t, and work_mem.

Referenced by hash_create_memory().

◆ ExecAssignExprContext()

void ExecAssignExprContext	(	EState *	estate,
		PlanState *	planstate
	)

Definition at line 490 of file execUtils.c.

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

References CreateExprContext(), and PlanState::ps_ExprContext.

Referenced by ExecInitAgg(), ExecInitBitmapHeapScan(), ExecInitBitmapIndexScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitInsertProjection(), ExecInitLimit(), ExecInitMemoize(), ExecInitMerge(), 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 588 of file execUtils.c.

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

References ExecBuildProjectionInfo(), fb(), 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 697 of file execUtils.c.

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

References ExecSetSlotDescriptor(), and fb().

Referenced by ExecWorkTableScan().

◆ ExecCleanTargetListLength()

int ExecCleanTargetListLength ( List * targetlist )

Definition at line 1211 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 fb(), len, and lfirst_node.

Referenced by ApplyRetrieveRule(), check_sql_stmt_retval(), and ExecTypeFromTLInternal().

◆ ExecConditionalAssignProjectionInfo()

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

Definition at line 608 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(), fb(), 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 709 of file execUtils.c.

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

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

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

◆ ExecGetAllNullSlot()

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

Definition at line 1299 of file execUtils.c.

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

References EState::es_query_cxt, ExecInitExtraTupleSlot(), ExecStoreAllNullTuple(), fb(), MemoryContextSwitchTo(), RelationGetDescr, and table_slot_callbacks().

Referenced by ExecProcessReturning().

◆ ExecGetAllUpdatedCols()

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

Definition at line 1444 of file execUtils.c.

{
    Bitmapset  *ret;
    MemoryContext oldcxt;
 
    oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
 
    ret = bms_union(ExecGetUpdatedCols(relinfo, estate),
                    ExecGetExtraUpdatedCols(relinfo, estate));
 
    MemoryContextSwitchTo(oldcxt);
 
    return ret;
}

References bms_union(), ExecGetExtraUpdatedCols(), ExecGetUpdatedCols(), fb(), GetPerTupleMemoryContext, and MemoryContextSwitchTo().

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

◆ ExecGetChildToRootMap()

TupleConversionMap * ExecGetChildToRootMap ( ResultRelInfo * resultRelInfo )

Definition at line 1326 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(), fb(), RelationGetDescr, ResultRelInfo::ri_ChildToRootMap, ResultRelInfo::ri_ChildToRootMapValid, ResultRelInfo::ri_RelationDesc, and ResultRelInfo::ri_RootResultRelInfo.

Referenced by adjust_partition_colnos(), AfterTriggerExecute(), AfterTriggerSaveEvent(), ExecCrossPartitionUpdate(), ExecDelete(), ExecForPortionOfLeftovers(), and TransitionTableAddTuple().

◆ ExecGetCommonChildSlotOps()

const TupleTableSlotOps * ExecGetCommonChildSlotOps ( PlanState * ps )

Definition at line 568 of file execUtils.c.

{
    PlanState  *planstates[2];
 
    planstates[0] = outerPlanState(ps);
    planstates[1] = innerPlanState(ps);
    return ExecGetCommonSlotOps(planstates, 2);
}

References ExecGetCommonSlotOps(), fb(), innerPlanState, outerPlanState, and ps.

Referenced by build_hash_table(), and build_hash_table().

◆ ExecGetCommonSlotOps()

const TupleTableSlotOps * ExecGetCommonSlotOps	(	PlanState **	planstates,
		int	nplans
	)

Definition at line 541 of file execUtils.c.

{
    const TupleTableSlotOps *result;
    bool        isfixed;
 
    if (nplans <= 0)
        return NULL;
    result = ExecGetResultSlotOps(planstates[0], &isfixed);
    if (!isfixed)
        return NULL;
    for (int i = 1; i < nplans; i++)
    {
        const TupleTableSlotOps *thisops;
 
        thisops = ExecGetResultSlotOps(planstates[i], &isfixed);
        if (!isfixed)
            return NULL;
        if (result != thisops)
            return NULL;
    }
    return result;
}

References ExecGetResultSlotOps(), fb(), i, and result.

Referenced by ExecGetCommonChildSlotOps(), ExecInitAppend(), and ExecInitMergeAppend().

◆ ExecGetExtraUpdatedCols()

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

Definition at line 1429 of file execUtils.c.

{
    /* Compute the info if we didn't already */
    if (!relinfo->ri_extraUpdatedCols_valid)
        ExecInitGenerated(relinfo, estate, CMD_UPDATE);
    return relinfo->ri_extraUpdatedCols;
}

References CMD_UPDATE, ExecInitGenerated(), and fb().

Referenced by ExecGetAllUpdatedCols(), and index_unchanged_by_update().

◆ ExecGetInsertedCols()

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

Definition at line 1387 of file execUtils.c.

{
    RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relinfo, estate);
 
    if (perminfo == NULL)
        return NULL;
 
    /* Map the columns to child's attribute numbers if needed. */
    if (relinfo->ri_RootResultRelInfo)
    {
        TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
 
        if (map)
            return execute_attr_map_cols(map->attrMap, perminfo->insertedCols);
    }
 
    return perminfo->insertedCols;
}

References TupleConversionMap::attrMap, ExecGetRootToChildMap(), execute_attr_map_cols(), fb(), and GetResultRTEPermissionInfo().

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

◆ ExecGetRangeTableRelation()

Relation ExecGetRangeTableRelation	(	EState *	estate,
		Index	rti,
		bool	isResultRel
	)

Definition at line 851 of file execUtils.c.

{
    Relation    rel;
 
    Assert(rti > 0 && rti <= estate->es_range_table_size);
 
    if (!isResultRel && !bms_is_member(rti, estate->es_unpruned_relids))
        elog(ERROR, "trying to open a pruned relation");
 
    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, bms_is_member(), CheckRelationLockedByMe(), elog, ERROR, EState::es_relations, EState::es_unpruned_relids, exec_rt_fetch(), fb(), IsParallelWorker, NoLock, RTE_RELATION, and table_open().

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

◆ ExecGetResultRelCheckAsUser()

Oid ExecGetResultRelCheckAsUser	(	ResultRelInfo *	relInfo,
		EState *	estate
	)

Definition at line 1515 of file execUtils.c.

{
    RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relInfo, estate);
 
    /* XXX - maybe ok to return GetUserId() in this case? */
    if (perminfo == NULL)
        elog(ERROR, "no RTEPermissionInfo found for result relation with OID %u",
             RelationGetRelid(relInfo->ri_RelationDesc));
 
    return perminfo->checkAsUser ? perminfo->checkAsUser : GetUserId();
}

References elog, ERROR, fb(), GetResultRTEPermissionInfo(), GetUserId(), and RelationGetRelid.

Referenced by create_foreign_modify().

◆ ExecGetResultSlotOps()

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

Definition at line 509 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(), ExecGetCommonSlotOps(), ExecInitAgg(), ExecInitGroup(), ExecInitHashJoin(), ExecInitLimit(), ExecInitLockRows(), ExecInitMergeJoin(), and ExecInitSubqueryScan().

◆ ExecGetResultType()

TupleDesc ExecGetResultType ( PlanState * planstate )

Definition at line 500 of file execUtils.c.

{
    return planstate->ps_ResultTupleDesc;
}

References PlanState::ps_ResultTupleDesc.

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

◆ ExecGetReturningSlot()

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

Definition at line 1274 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(), fb(), MemoryContextSwitchTo(), RelationGetDescr, and table_slot_callbacks().

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

◆ ExecGetRootToChildMap()

TupleConversionMap * ExecGetRootToChildMap	(	ResultRelInfo *	resultRelInfo,
		EState *	estate
	)

Definition at line 1352 of file execUtils.c.

{
    /* Mustn't get called for a non-child result relation. */
    Assert(resultRelInfo->ri_RootResultRelInfo);
 
    /* If we didn't already do so, compute the map for this child. */
    if (!resultRelInfo->ri_RootToChildMapValid)
    {
        ResultRelInfo *rootRelInfo = resultRelInfo->ri_RootResultRelInfo;
        TupleDesc   indesc = RelationGetDescr(rootRelInfo->ri_RelationDesc);
        TupleDesc   outdesc = RelationGetDescr(resultRelInfo->ri_RelationDesc);
        Relation    childrel = resultRelInfo->ri_RelationDesc;
        AttrMap    *attrMap;
        MemoryContext oldcontext;
 
        /*
         * When this child table is not a partition (!relispartition), it may
         * have columns that are not present in the root table, which we ask
         * to ignore by passing true for missing_ok.
         */
        oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
        attrMap = build_attrmap_by_name_if_req(indesc, outdesc,
                                               !childrel->rd_rel->relispartition);
        if (attrMap)
            resultRelInfo->ri_RootToChildMap =
                convert_tuples_by_name_attrmap(indesc, outdesc, attrMap);
        MemoryContextSwitchTo(oldcontext);
        resultRelInfo->ri_RootToChildMapValid = true;
    }
 
    return resultRelInfo->ri_RootToChildMap;
}

References Assert, build_attrmap_by_name_if_req(), convert_tuples_by_name_attrmap(), EState::es_query_cxt, fb(), MemoryContextSwitchTo(), RelationGetDescr, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_RootResultRelInfo, ResultRelInfo::ri_RootToChildMap, and ResultRelInfo::ri_RootToChildMapValid.

Referenced by apply_handle_tuple_routing(), CopyFrom(), ExecFindPartition(), ExecGetInsertedCols(), ExecGetUpdatedCols(), ExecInitPartitionInfo(), ExecInitRoutingInfo(), ExecInsert(), and ExecPrepareTupleRouting().

◆ ExecGetTriggerNewSlot()

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

Definition at line 1252 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(), fb(), MemoryContextSwitchTo(), RelationGetDescr, and table_slot_callbacks().

Referenced by AfterTriggerExecute(), and AfterTriggerSaveEvent().

◆ ExecGetTriggerOldSlot()

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

Definition at line 1230 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(), fb(), MemoryContextSwitchTo(), RelationGetDescr, and table_slot_callbacks().

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

◆ ExecGetUpdatedCols()

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

Definition at line 1408 of file execUtils.c.

{
    RTEPermissionInfo *perminfo = GetResultRTEPermissionInfo(relinfo, estate);
 
    if (perminfo == NULL)
        return NULL;
 
    /* Map the columns to child's attribute numbers if needed. */
    if (relinfo->ri_RootResultRelInfo)
    {
        TupleConversionMap *map = ExecGetRootToChildMap(relinfo, estate);
 
        if (map)
            return execute_attr_map_cols(map->attrMap, perminfo->updatedCols);
    }
 
    return perminfo->updatedCols;
}

References TupleConversionMap::attrMap, ExecGetRootToChildMap(), execute_attr_map_cols(), fb(), and GetResultRTEPermissionInfo().

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

◆ ExecInitRangeTable()

void ExecInitRangeTable	(	EState *	estate,
		List *	rangeTable,
		List *	permInfos,
		Bitmapset *	unpruned_relids
	)

Definition at line 799 of file execUtils.c.

{
    /* Remember the range table List as-is */
    estate->es_range_table = rangeTable;
 
    /* ... and the RTEPermissionInfo List too */
    estate->es_rteperminfos = permInfos;
 
    /* Set size of associated arrays */
    estate->es_range_table_size = list_length(rangeTable);
 
    /*
     * Initialize the bitmapset of RT indexes (es_unpruned_relids)
     * representing relations that will be scanned during execution. This set
     * is initially populated by the caller and may be extended later by
     * ExecDoInitialPruning() to include RT indexes of unpruned leaf
     * partitions.
     */
    estate->es_unpruned_relids = unpruned_relids;
 
    /*
     * 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, EState::es_rteperminfos, EState::es_unpruned_relids, fb(), list_length(), and palloc0().

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

◆ ExecInitResultRelation()

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

Definition at line 906 of file execUtils.c.

{
    Relation    resultRelationDesc;
 
    resultRelationDesc = ExecGetRangeTableRelation(estate, rti, true);
    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(), fb(), InitResultRelInfo(), lappend(), and palloc0().

Referenced by CopyFrom(), and ExecInitModifyTable().

◆ ExecOpenScanRelation()

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

Definition at line 768 of file execUtils.c.

{
    Relation    rel;
 
    /* Open the relation. */
    rel = ExecGetRangeTableRelation(estate, scanrelid, false);
 
    /*
     * 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(), fb(), 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 734 of file execUtils.c.

{
    return bms_is_member(scanrelid, estate->es_plannedstmt->resultRelationRelids);
}

References bms_is_member(), EState::es_plannedstmt, and PlannedStmt::resultRelationRelids.

◆ ExecTargetListLength()

int ExecTargetListLength ( List * targetlist )

Definition at line 1201 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 962 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, fb(), and pg_mbstrlen_with_len().

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

◆ FreeExecutorState()

void FreeExecutorState ( EState * estate )

Definition at line 197 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, fb(), FreeExprContext(), jit_release_context(), linitial, and MemoryContextDelete().

Referenced by afterTriggerInvokeEvents(), ATExecAddColumn(), ATRewriteTable(), check_default_partition_contents(), compute_expr_stats(), compute_index_stats(), CopyFrom(), EvalPlanQualEnd(), evaluate_expr(), ExecuteCallStmt(), ExecuteQuery(), ExecuteTruncateGuts(), ExplainExecuteQuery(), finish_edata(), freestate_cluster(), get_qual_for_range(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), make_build_data(), MergePartitionsMoveRows(), operator_predicate_proof(), plpgsql_inline_handler(), plpgsql_xact_cb(), release_change_context(), SplitPartitionMoveRows(), standard_ExecutorEnd(), unique_key_recheck(), and validateDomainCheckConstraint().

◆ FreeExprContext()

void FreeExprContext	(	ExprContext *	econtext,
		bool	isCommit
	)

Definition at line 421 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, fb(), list_delete_ptr(), MemoryContextDelete(), pfree(), and ShutdownExprContext().

Referenced by FreeExecutorState(), plpgsql_destroy_econtext(), and plpgsql_subxact_cb().

◆ GetAttributeByName()

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

Definition at line 1087 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, fb(), heap_getattr(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), i, InvalidAttrNumber, InvalidOid, ItemPointerSetInvalid(), lookup_rowtype_tupdesc(), namestrcmp(), TupleDescData::natts, ReleaseTupleDesc, result, and TupleDescAttr().

Referenced by c_overpaid(), and overpaid().

◆ GetAttributeByNum()

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

Definition at line 1150 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, fb(), heap_getattr(), HeapTupleHeaderGetDatumLength(), HeapTupleHeaderGetTypeId(), HeapTupleHeaderGetTypMod(), InvalidOid, ItemPointerSetInvalid(), lookup_rowtype_tupdesc(), ReleaseTupleDesc, and result.

◆ GetResultRTEPermissionInfo()

static RTEPermissionInfo * GetResultRTEPermissionInfo	(	ResultRelInfo *	relinfo,
		EState *	estate
	)

static

Definition at line 1464 of file execUtils.c.

{
    Index       rti;
    RangeTblEntry *rte;
    RTEPermissionInfo *perminfo = NULL;
 
    if (relinfo->ri_RootResultRelInfo)
    {
        /*
         * For inheritance child result relations (a partition routing target
         * of an INSERT or a child UPDATE target), this returns the root
         * parent's RTE to fetch the RTEPermissionInfo because that's the only
         * one that has one assigned.
         */
        rti = relinfo->ri_RootResultRelInfo->ri_RangeTableIndex;
    }
    else if (relinfo->ri_RangeTableIndex != 0)
    {
        /*
         * Non-child result relation should have their own RTEPermissionInfo.
         */
        rti = relinfo->ri_RangeTableIndex;
    }
    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.)
         */
        rti = 0;
    }
 
    if (rti > 0)
    {
        rte = exec_rt_fetch(rti, estate);
        perminfo = getRTEPermissionInfo(estate->es_rteperminfos, rte);
    }
 
    return perminfo;
}

References EState::es_rteperminfos, exec_rt_fetch(), fb(), and getRTEPermissionInfo().

Referenced by ExecGetInsertedCols(), ExecGetResultRelCheckAsUser(), and ExecGetUpdatedCols().

◆ MakePerTupleExprContext()

ExprContext * MakePerTupleExprContext ( EState * estate )

Definition at line 463 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(), EState::es_per_tuple_exprcontext, and fb().

◆ RegisterExprContextCallback()

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

Definition at line 989 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::ecxt_callbacks, ExprContext::ecxt_per_query_memory, fb(), function, ExprContext_CB::function, and MemoryContextAlloc().

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

◆ ReScanExprContext()

void ReScanExprContext ( ExprContext * econtext )

Definition at line 448 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().

◆ ScanRelIsReadOnly()

bool ScanRelIsReadOnly ( ScanState * ss )

Definition at line 751 of file execUtils.c.

{
    Index       scanrelid = ((Scan *) ss->ps.plan)->scanrelid;
    PlannedStmt *pstmt = ss->ps.state->es_plannedstmt;
 
    return !bms_is_member(scanrelid, pstmt->resultRelationRelids) &&
        !bms_is_member(scanrelid, pstmt->rowMarkRelids);
}

References bms_is_member(), EState::es_plannedstmt, PlanState::plan, ScanState::ps, PlannedStmt::resultRelationRelids, PlannedStmt::rowMarkRelids, and PlanState::state.

Referenced by BitmapTableScanSetup(), ExecIndexOnlyScanInitializeDSM(), ExecIndexOnlyScanInitializeWorker(), ExecIndexScanInitializeDSM(), ExecIndexScanInitializeWorker(), ExecSeqScanInitializeDSM(), ExecSeqScanInitializeWorker(), ExecTidRangeScanInitializeDSM(), ExecTidRangeScanInitializeWorker(), IndexNext(), IndexNextWithReorder(), IndexOnlyNext(), SeqNext(), tablesample_init(), and TidRangeNext().

◆ ShutdownExprContext()

static void ShutdownExprContext	(	ExprContext *	econtext,
		bool	isCommit
	)

static

Definition at line 1046 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::ecxt_callbacks, ExprContext::ecxt_per_tuple_memory, fb(), 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 635 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, fb(), IsA, lfirst, list_head(), lnext(), TupleDescData::natts, TupleDescAttr(), Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by ExecConditionalAssignProjectionInfo().

◆ UnregisterExprContextCallback()

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

Definition at line 1015 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::ecxt_callbacks, fb(), function, ExprContext_CB::next, and pfree().

Referenced by end_MultiFuncCall(), and fmgr_sql().

◆ UpdateChangedParamSet()

void UpdateChangedParamSet	(	PlanState *	node,
		Bitmapset *	newchg
	)

Definition at line 936 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);
    node->chgParam = bms_join(node->chgParam, parmset);
}

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

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

Functions

Function Documentation

◆ CreateExecutorState()

◆ CreateExprContext()

◆ CreateExprContextInternal()

◆ CreateStandaloneExprContext()

◆ CreateWorkExprContext()

◆ ExecAssignExprContext()

◆ ExecAssignProjectionInfo()

◆ ExecAssignScanType()

◆ ExecCleanTargetListLength()

◆ ExecConditionalAssignProjectionInfo()

◆ ExecCreateScanSlotFromOuterPlan()

◆ ExecGetAllNullSlot()

◆ ExecGetAllUpdatedCols()

◆ ExecGetChildToRootMap()

◆ ExecGetCommonChildSlotOps()

◆ ExecGetCommonSlotOps()

◆ ExecGetExtraUpdatedCols()

◆ ExecGetInsertedCols()

◆ ExecGetRangeTableRelation()

◆ ExecGetResultRelCheckAsUser()

◆ ExecGetResultSlotOps()

◆ ExecGetResultType()

◆ ExecGetReturningSlot()

◆ ExecGetRootToChildMap()

◆ ExecGetTriggerNewSlot()

◆ ExecGetTriggerOldSlot()

◆ ExecGetUpdatedCols()

◆ ExecInitRangeTable()

◆ ExecInitResultRelation()

◆ ExecOpenScanRelation()

◆ ExecRelationIsTargetRelation()

◆ ExecTargetListLength()

◆ executor_errposition()

◆ FreeExecutorState()

◆ FreeExprContext()

◆ GetAttributeByName()

◆ GetAttributeByNum()

◆ GetResultRTEPermissionInfo()

◆ MakePerTupleExprContext()

◆ RegisterExprContextCallback()

◆ ReScanExprContext()

◆ ScanRelIsReadOnly()

◆ ShutdownExprContext()

◆ tlist_matches_tupdesc()

◆ UnregisterExprContextCallback()

◆ UpdateChangedParamSet()