#include "postgres.h"
#include "access/relscan.h"
#include "access/transam.h"
#include "executor/executor.h"
#include "mb/pg_wchar.h"
#include "nodes/nodeFuncs.h"
#include "parser/parsetree.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 void	ShutdownExprContext (ExprContext *econtext, bool isCommit)

EState *	CreateExecutorState (void)

void	FreeExecutorState (EState *estate)

ExprContext *	CreateExprContext (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)

void	ExecAssignResultType (PlanState *planstate, TupleDesc tupDesc)

void	ExecAssignResultTypeFromTL (PlanState *planstate)

TupleDesc	ExecGetResultType (PlanState *planstate)

void	ExecAssignProjectionInfo (PlanState *planstate, TupleDesc inputDesc)

void	ExecFreeExprContext (PlanState *planstate)

void	ExecAssignScanType (ScanState *scanstate, TupleDesc tupDesc)

void	ExecAssignScanTypeFromOuterPlan (ScanState *scanstate)

bool	ExecRelationIsTargetRelation (EState *estate, Index scanrelid)

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

void	ExecCloseScanRelation (Relation scanrel)

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)

void	ExecLockNonLeafAppendTables (List partitioned_rels, EState estate)

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)

Function Documentation

EState* CreateExecutorState ( void )

Definition at line 80 of file execUtils.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate(), CurrentMemoryContext, EState::es_auxmodifytables, EState::es_crosscheck_snapshot, EState::es_direction, EState::es_epqScanDone, EState::es_epqTuple, EState::es_epqTupleSet, EState::es_exprcontexts, EState::es_finished, EState::es_instrument, EState::es_junkFilter, EState::es_lastoid, EState::es_num_result_relations, EState::es_output_cid, EState::es_param_exec_vals, EState::es_param_list_info, EState::es_per_tuple_exprcontext, EState::es_plannedstmt, EState::es_processed, EState::es_query_cxt, EState::es_queryEnv, EState::es_range_table, EState::es_result_relation_info, EState::es_result_relations, EState::es_rowMarks, EState::es_snapshot, EState::es_sourceText, EState::es_subplanstates, EState::es_top_eflags, EState::es_trig_newtup_slot, EState::es_trig_oldtup_slot, EState::es_trig_target_relations, EState::es_trig_tuple_slot, EState::es_tupleTable, ForwardScanDirection, InvalidOid, InvalidSnapshot, makeNode, MemoryContextSwitchTo(), NIL, and NULL.

Referenced by afterTriggerInvokeEvents(), ATRewriteTable(), compute_index_stats(), CopyFrom(), create_estate_for_relation(), EvalPlanQualStart(), evaluate_expr(), ExecuteQuery(), ExecuteTruncate(), ExplainExecuteQuery(), get_actual_variable_range(), get_qual_for_range(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), operator_predicate_proof(), plpgsql_create_econtext(), plpgsql_inline_handler(), standard_ExecutorStart(), tuplesort_begin_cluster(), unique_key_recheck(), validate_index_heapscan(), validateCheckConstraint(), and validateDomainConstraint().

 {
     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_plannedstmt = NULL;
 
     estate->es_junkFilter = NULL;
 
     estate->es_output_cid = (CommandId) 0;
 
     estate->es_result_relations = NULL;
     estate->es_num_result_relations = 0;
     estate->es_result_relation_info = NULL;
 
     estate->es_trig_target_relations = NIL;
     estate->es_trig_tuple_slot = NULL;
     estate->es_trig_oldtup_slot = NULL;
     estate->es_trig_newtup_slot = NULL;
 
     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_rowMarks = NIL;
 
     estate->es_processed = 0;
     estate->es_lastoid = InvalidOid;
 
     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_epqTuple = NULL;
     estate->es_epqTupleSet = NULL;
     estate->es_epqScanDone = NULL;
     estate->es_sourceText = NULL;
 
     /*
      * Return the executor state structure
      */
     MemoryContextSwitchTo(oldcontext);
 
     return estate;
 }

ExprContext* CreateExprContext ( EState * estate )

Definition at line 218 of file execUtils.c.

References ALLOCSET_DEFAULT_SIZES, 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, MemoryContextSwitchTo(), and NULL.

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

 {
     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",
                               ALLOCSET_DEFAULT_SIZES);
 
     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;
 }

ExprContext* CreateStandaloneExprContext ( void )

Definition at line 290 of file execUtils.c.

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, makeNode, and NULL.

Referenced by domain_check_input().

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

void ExecAssignExprContext	(	EState *	estate,
		PlanState *	planstate
	)

Definition at line 418 of file execUtils.c.

References CreateExprContext(), and PlanState::ps_ExprContext.

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

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

void ExecAssignProjectionInfo	(	PlanState *	planstate,
		TupleDesc	inputDesc
	)

Definition at line 487 of file execUtils.c.

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

Referenced by ExecAssignScanProjectionInfoWithVarno(), ExecInitAgg(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHashJoin(), ExecInitMergeJoin(), ExecInitNestLoop(), ExecInitResult(), and ExecInitWindowAgg().

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

void ExecAssignResultType	(	PlanState *	planstate,
		TupleDesc	tupDesc
	)

Definition at line 428 of file execUtils.c.

References ExecSetSlotDescriptor(), and PlanState::ps_ResultTupleSlot.

Referenced by ExecAssignResultTypeFromTL(), and ExecInitModifyTable().

 {
     TupleTableSlot *slot = planstate->ps_ResultTupleSlot;
 
     ExecSetSlotDescriptor(slot, tupDesc);
 }

void ExecAssignResultTypeFromTL ( PlanState * planstate )

Definition at line 440 of file execUtils.c.

References ExecAssignResultType(), ExecContextForcesOids(), ExecTypeFromTL(), PlanState::plan, and Plan::targetlist.

Referenced by ExecInitAgg(), ExecInitAppend(), ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitGather(), ExecInitGatherMerge(), ExecInitGroup(), ExecInitHash(), ExecInitHashJoin(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitLimit(), ExecInitLockRows(), ExecInitMaterial(), ExecInitMergeAppend(), ExecInitMergeJoin(), ExecInitNamedTuplestoreScan(), ExecInitNestLoop(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitResult(), ExecInitSampleScan(), ExecInitSeqScan(), ExecInitSetOp(), ExecInitSort(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidScan(), ExecInitUnique(), ExecInitValuesScan(), ExecInitWindowAgg(), and ExecInitWorkTableScan().

 {
     bool        hasoid;
     TupleDesc   tupDesc;
 
     if (ExecContextForcesOids(planstate, &hasoid))
     {
         /* context forces OID choice; hasoid is now set correctly */
     }
     else
     {
         /* given free choice, don't leave space for OIDs in result tuples */
         hasoid = false;
     }
 
     /*
      * ExecTypeFromTL needs the parse-time representation of the tlist, not a
      * list of ExprStates.  This is good because some plan nodes don't bother
      * to set up planstate->targetlist ...
      */
     tupDesc = ExecTypeFromTL(planstate->plan->targetlist, hasoid);
     ExecAssignResultType(planstate, tupDesc);
 }

void ExecAssignScanType	(	ScanState *	scanstate,
		TupleDesc	tupDesc
	)

Definition at line 540 of file execUtils.c.

References ExecSetSlotDescriptor(), and ScanState::ss_ScanTupleSlot.

Referenced by ExecAssignScanTypeFromOuterPlan(), ExecInitBitmapHeapScan(), ExecInitCteScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitFunctionScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitNamedTuplestoreScan(), ExecInitSubqueryScan(), ExecInitTableFuncScan(), ExecInitTidScan(), ExecInitValuesScan(), ExecWorkTableScan(), and InitScanRelation().

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

void ExecAssignScanTypeFromOuterPlan ( ScanState * scanstate )

Definition at line 552 of file execUtils.c.

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

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

 {
     PlanState  *outerPlan;
     TupleDesc   tupDesc;
 
     outerPlan = outerPlanState(scanstate);
     tupDesc = ExecGetResultType(outerPlan);
 
     ExecAssignScanType(scanstate, tupDesc);
 }

int ExecCleanTargetListLength ( List * targetlist )

Definition at line 1007 of file execUtils.c.

References lfirst_node, and TargetEntry::resjunk.

Referenced by check_sql_fn_retval(), and ExecTypeFromTLInternal().

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

void ExecCloseScanRelation ( Relation scanrel )

Definition at line 661 of file execUtils.c.

References heap_close, and NoLock.

Referenced by ExecEndBitmapHeapScan(), ExecEndCustomScan(), ExecEndForeignScan(), ExecEndIndexOnlyScan(), ExecEndIndexScan(), ExecEndSampleScan(), ExecEndSeqScan(), and ExecEndTidScan().

 {
     heap_close(scanrel, NoLock);
 }

void ExecFreeExprContext ( PlanState * planstate )

Definition at line 516 of file execUtils.c.

References NULL, and PlanState::ps_ExprContext.

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

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

TupleDesc ExecGetResultType ( PlanState * planstate )

Definition at line 469 of file execUtils.c.

References PlanState::ps_ResultTupleSlot, and TupleTableSlot::tts_tupleDescriptor.

Referenced by ExecAssignScanTypeFromOuterPlan(), ExecInitCteScan(), ExecInitHashJoin(), ExecInitMergeJoin(), ExecInitNestLoop(), ExecInitSubqueryScan(), ExecInitWholeRowVar(), ExecSort(), ExecWorkTableScan(), initialize_phase(), and InitPlan().

 {
     TupleTableSlot *slot = planstate->ps_ResultTupleSlot;
 
     return slot->tts_tupleDescriptor;
 }

void ExecLockNonLeafAppendTables	(	List *	partitioned_rels,
		EState *	estate
	)

Definition at line 826 of file execUtils.c.

References AccessShareLock, EState::es_plannedstmt, EState::es_range_table, getrelid, lfirst, lfirst_int, LockRelationOid(), PlanRowMark::markType, PlannedStmt::nonleafResultRelations, NULL, RowMarkRequiresRowShareLock, PlannedStmt::rowMarks, and RowShareLock.

Referenced by ExecInitAppend(), and ExecInitMergeAppend().

 {
     PlannedStmt *stmt = estate->es_plannedstmt;
     ListCell   *lc;
 
     foreach(lc, partitioned_rels)
     {
         ListCell   *l;
         Index       rti = lfirst_int(lc);
         bool        is_result_rel = false;
         Oid         relid = getrelid(rti, estate->es_range_table);
 
         /* If this is a result relation, already locked in InitPlan */
         foreach(l, stmt->nonleafResultRelations)
         {
             if (rti == lfirst_int(l))
             {
                 is_result_rel = true;
                 break;
             }
         }
 
         /*
          * Not a result relation; check if there is a RowMark that requires
          * taking a RowShareLock on this rel.
          */
         if (!is_result_rel)
         {
             PlanRowMark *rc = NULL;
 
             foreach(l, stmt->rowMarks)
             {
                 if (((PlanRowMark *) lfirst(l))->rti == rti)
                 {
                     rc = lfirst(l);
                     break;
                 }
             }
 
             if (rc && RowMarkRequiresRowShareLock(rc->markType))
                 LockRelationOid(relid, RowShareLock);
             else
                 LockRelationOid(relid, AccessShareLock);
         }
     }
 }

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

Definition at line 603 of file execUtils.c.

References AccessShareLock, ereport, errcode(), errhint(), errmsg(), ERROR, EState::es_range_table, EXEC_FLAG_EXPLAIN_ONLY, EXEC_FLAG_WITH_NO_DATA, ExecFindRowMark(), ExecRelationIsTargetRelation(), getrelid, heap_open(), NoLock, NULL, ExecRowMark::relation, RelationGetRelationName, and RelationIsScannable.

Referenced by ExecInitBitmapHeapScan(), ExecInitCustomScan(), ExecInitForeignScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), ExecInitTidScan(), and InitScanRelation().

 {
     Relation    rel;
     Oid         reloid;
     LOCKMODE    lockmode;
 
     /*
      * Determine the lock type we need.  First, scan to see if target relation
      * is a result relation.  If not, check if it's a FOR UPDATE/FOR SHARE
      * relation.  In either of those cases, we got the lock already.
      */
     lockmode = AccessShareLock;
     if (ExecRelationIsTargetRelation(estate, scanrelid))
         lockmode = NoLock;
     else
     {
         /* Keep this check in sync with InitPlan! */
         ExecRowMark *erm = ExecFindRowMark(estate, scanrelid, true);
 
         if (erm != NULL && erm->relation != NULL)
             lockmode = NoLock;
     }
 
     /* Open the relation and acquire lock as needed */
     reloid = getrelid(scanrelid, estate->es_range_table);
     rel = heap_open(reloid, lockmode);
 
     /*
      * 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;
 }

bool ExecRelationIsTargetRelation	(	EState *	estate,
		Index	scanrelid
	)

Definition at line 577 of file execUtils.c.

References EState::es_num_result_relations, EState::es_result_relations, and i.

Referenced by ExecInitBitmapIndexScan(), ExecInitIndexOnlyScan(), ExecInitIndexScan(), and ExecOpenScanRelation().

 {
     ResultRelInfo *resultRelInfos;
     int         i;
 
     resultRelInfos = estate->es_result_relations;
     for (i = 0; i < estate->es_num_result_relations; i++)
     {
         if (resultRelInfos[i].ri_RangeTableIndex == scanrelid)
             return true;
     }
     return false;
 }

int ExecTargetListLength ( List * targetlist )

Definition at line 997 of file execUtils.c.

References list_length().

Referenced by ExecTypeFromTLInternal().

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

int executor_errposition	(	EState *	estate,
		int	location
	)

Definition at line 705 of file execUtils.c.

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

Referenced by ExecInitFunc(), and init_sexpr().

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

void FreeExecutorState ( EState * estate )

Definition at line 178 of file execUtils.c.

References EState::es_exprcontexts, EState::es_query_cxt, FreeExprContext(), linitial, and MemoryContextDelete().

Referenced by afterTriggerInvokeEvents(), apply_handle_delete(), apply_handle_insert(), apply_handle_update(), ATRewriteTable(), compute_index_stats(), CopyFrom(), EvalPlanQualEnd(), evaluate_expr(), ExecuteQuery(), ExecuteTruncate(), ExplainExecuteQuery(), get_actual_variable_range(), get_qual_for_range(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), operator_predicate_proof(), plpgsql_inline_handler(), plpgsql_xact_cb(), standard_ExecutorEnd(), tuplesort_end(), unique_key_recheck(), validate_index_heapscan(), validateCheckConstraint(), and validateDomainConstraint().

 {
     /*
      * 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 */
     }
 
     /*
      * Free the per-query memory context, thereby releasing all working
      * memory, including the EState node itself.
      */
     MemoryContextDelete(estate->es_query_cxt);
 }

void FreeExprContext	(	ExprContext *	econtext,
		bool	isCommit
	)

Definition at line 349 of file execUtils.c.

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

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

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

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

Definition at line 885 of file execUtils.c.

References tupleDesc::attrs, elog, ERROR, heap_getattr, HeapTupleHeaderGetDatumLength, HeapTupleHeaderGetTypeId, HeapTupleHeaderGetTypMod, i, InvalidAttrNumber, InvalidOid, ItemPointerSetInvalid, lookup_rowtype_tupdesc(), namestrcmp(), tupleDesc::natts, NULL, ReleaseTupleDesc, result, HeapTupleData::t_data, HeapTupleData::t_len, HeapTupleData::t_self, and HeapTupleData::t_tableOid.

Referenced by c_overpaid(), and overpaid().

 {
     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++)
     {
         if (namestrcmp(&(tupDesc->attrs[i]->attname), attname) == 0)
         {
             attrno = tupDesc->attrs[i]->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;
 }

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

Definition at line 946 of file execUtils.c.

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

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

ExprContext* MakePerTupleExprContext ( EState * estate )

Definition at line 391 of file execUtils.c.

References CreateExprContext(), EState::es_per_tuple_exprcontext, and NULL.

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

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

Definition at line 732 of file execUtils.c.

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

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

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

void ReScanExprContext ( ExprContext * econtext )

Definition at line 376 of file execUtils.c.

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

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

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

static void ShutdownExprContext	(	ExprContext *	econtext,
		bool	isCommit
	)

static

Definition at line 789 of file execUtils.c.

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

Referenced by FreeExprContext(), and ReScanExprContext().

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

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

Definition at line 758 of file execUtils.c.

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

Referenced by end_MultiFuncCall(), and fmgr_sql().

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

void UpdateChangedParamSet	(	PlanState *	node,
		Bitmapset *	newchg
	)

Definition at line 671 of file execUtils.c.

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

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

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

Functions

Function Documentation