execUtils.c File Reference

#include "postgres.h"
#include "access/parallel.h"
#include "access/table.h"
#include "access/tableam.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 "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)
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)
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 88 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_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_aborted = 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_aborted, 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_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_use_parallel_mode, 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(), make_build_data(), operator_predicate_proof(), plpgsql_create_econtext(), plpgsql_inline_handler(), standard_ExecutorStart(), tuplesort_begin_cluster(), and validateDomainCheckConstraint().

CreateExprContext()

ExprContext * CreateExprContext

(

EState *

estate

)

Definition at line 308 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 238 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 358 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 BuildTupleHashTable(), domain_check_input(), and hypothetical_dense_rank_final().

CreateWorkExprContext()

ExprContext * CreateWorkExprContext

(

EState *

estate

)

Definition at line 323 of file execUtils.c.

{
    Size        maxBlockSize = ALLOCSET_DEFAULT_MAXSIZE;
 
    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 486 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 584 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 693 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 1186 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, and lfirst_node.

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

ExecConditionalAssignProjectionInfo()

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

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

ExecGetAllNullSlot()

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

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

Referenced by ExecProcessReturning().

ExecGetAllUpdatedCols()

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

Definition at line 1419 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(), GetPerTupleMemoryContext, and MemoryContextSwitchTo().

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

ExecGetChildToRootMap()

TupleConversionMap * ExecGetChildToRootMap

(

ResultRelInfo *

resultRelInfo

)

Definition at line 1301 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(), AfterTriggerExecute(), AfterTriggerSaveEvent(), ExecCrossPartitionUpdate(), ExecDelete(), and TransitionTableAddTuple().

ExecGetCommonChildSlotOps()

const TupleTableSlotOps * ExecGetCommonChildSlotOps

(

PlanState *

ps

)

Definition at line 564 of file execUtils.c.

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

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

Referenced by build_hash_table().

ExecGetCommonSlotOps()

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

Definition at line 537 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(), and i.

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

ExecGetExtraUpdatedCols()

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

Definition at line 1404 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(), ResultRelInfo::ri_extraUpdatedCols, and ResultRelInfo::ri_extraUpdatedCols_valid.

Referenced by ExecGetAllUpdatedCols(), and index_unchanged_by_update().

ExecGetInsertedCols()

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

Definition at line 1362 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(), GetResultRTEPermissionInfo(), RTEPermissionInfo::insertedCols, and ResultRelInfo::ri_RootResultRelInfo.

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

ExecGetRangeTableRelation()

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

Definition at line 826 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(), IsParallelWorker, NoLock, RTE_RELATION, RangeTblEntry::rtekind, and table_open().

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

ExecGetResultRelCheckAsUser()

Oid ExecGetResultRelCheckAsUser	(	ResultRelInfo *	relInfo,
		EState *	estate
	)

Definition at line 1490 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 RTEPermissionInfo::checkAsUser, elog, ERROR, GetResultRTEPermissionInfo(), GetUserId(), RelationGetRelid, and ResultRelInfo::ri_RelationDesc.

Referenced by create_foreign_modify().

ExecGetResultSlotOps()

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

Definition at line 505 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 496 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(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitUnique(), ExecSort(), ExecWorkTableScan(), initialize_phase(), InitPlan(), and switchToPresortedPrefixMode().

ExecGetReturningSlot()

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

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

ExecGetRootToChildMap()

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

Definition at line 1327 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, MemoryContextSwitchTo(), RelationData::rd_rel, 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 1227 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(), and AfterTriggerSaveEvent().

ExecGetTriggerOldSlot()

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

Definition at line 1205 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(), AfterTriggerSaveEvent(), ExecARDeleteTriggers(), ExecARUpdateTriggers(), ExecBRDeleteTriggers(), ExecBRUpdateTriggers(), ExecIRDeleteTriggers(), and ExecIRUpdateTriggers().

ExecGetUpdatedCols()

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

Definition at line 1383 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(), GetResultRTEPermissionInfo(), ResultRelInfo::ri_RootResultRelInfo, and RTEPermissionInfo::updatedCols.

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

ExecInitRangeTable()

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

Definition at line 774 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, 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 881 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(), InitResultRelInfo(), lappend(), and palloc0().

Referenced by CopyFrom(), and ExecInitModifyTable().

ExecOpenScanRelation()

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

Definition at line 743 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(), 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 730 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 1176 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 937 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 193 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(), 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(), operator_predicate_proof(), plpgsql_inline_handler(), plpgsql_xact_cb(), standard_ExecutorEnd(), and validateDomainCheckConstraint().

FreeExprContext()

void FreeExprContext	(	ExprContext *	econtext,
		bool	isCommit
	)

Definition at line 417 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 FreeExecutorState(), plpgsql_destroy_econtext(), and plpgsql_subxact_cb().

GetAttributeByName()

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

Definition at line 1062 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 1125 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.

GetResultRTEPermissionInfo()

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

static

Definition at line 1439 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(), getRTEPermissionInfo(), ResultRelInfo::ri_RangeTableIndex, and ResultRelInfo::ri_RootResultRelInfo.

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

MakePerTupleExprContext()

ExprContext * MakePerTupleExprContext

(

EState *

estate

)

Definition at line 459 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 964 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, function, 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 444 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 1021 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 631 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, and Var::varno.

Referenced by ExecConditionalAssignProjectionInfo().

UnregisterExprContextCallback()

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

Definition at line 990 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, function, 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 911 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, and PlanState::plan.

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