#include "postgres.h"
#include <limits.h>
#include "access/transam.h"
#include "catalog/namespace.h"
#include "executor/executor.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/optimizer.h"
#include "parser/analyze.h"
#include "storage/lmgr.h"
#include "tcop/pquery.h"
#include "tcop/utility.h"
#include "utils/inval.h"
#include "utils/memutils.h"
#include "utils/resowner.h"
#include "utils/rls.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for plancache.c:

Macros
#define	StmtPlanRequiresRevalidation(plansource)

Functions
static void	ReleaseGenericPlan (CachedPlanSource *plansource)

static List *	RevalidateCachedQuery (CachedPlanSource plansource, QueryEnvironment queryEnv, bool release_generic)

static bool	CheckCachedPlan (CachedPlanSource *plansource)

static CachedPlan *	BuildCachedPlan (CachedPlanSource plansource, List qlist, ParamListInfo boundParams, QueryEnvironment *queryEnv)

static bool	choose_custom_plan (CachedPlanSource *plansource, ParamListInfo boundParams)

static double	cached_plan_cost (CachedPlan *plan, bool include_planner)

static Query *	QueryListGetPrimaryStmt (List *stmts)

static void	AcquireExecutorLocks (List *stmt_list, bool acquire)

static void	AcquirePlannerLocks (List *stmt_list, bool acquire)

static void	ScanQueryForLocks (Query *parsetree, bool acquire)

static bool	ScanQueryWalker (Node node, bool acquire)

static TupleDesc	PlanCacheComputeResultDesc (List *stmt_list)

static void	PlanCacheRelCallback (Datum arg, Oid relid)

static void	PlanCacheObjectCallback (Datum arg, int cacheid, uint32 hashvalue)

static void	PlanCacheSysCallback (Datum arg, int cacheid, uint32 hashvalue)

static void	ResOwnerReleaseCachedPlan (Datum res)

static void	ResourceOwnerRememberPlanCacheRef (ResourceOwner owner, CachedPlan *plan)

static void	ResourceOwnerForgetPlanCacheRef (ResourceOwner owner, CachedPlan *plan)

void	InitPlanCache (void)

CachedPlanSource *	CreateCachedPlan (RawStmt raw_parse_tree, const char query_string, CommandTag commandTag)

CachedPlanSource *	CreateOneShotCachedPlan (RawStmt raw_parse_tree, const char query_string, CommandTag commandTag)

void	CompleteCachedPlan (CachedPlanSource plansource, List querytree_list, MemoryContext querytree_context, Oid param_types, int num_params, ParserSetupHook parserSetup, void parserSetupArg, int cursor_options, bool fixed_result)

void	SaveCachedPlan (CachedPlanSource *plansource)

void	DropCachedPlan (CachedPlanSource *plansource)

PlannedStmt *	UpdateCachedPlan (CachedPlanSource plansource, int query_index, QueryEnvironment queryEnv)

CachedPlan *	GetCachedPlan (CachedPlanSource plansource, ParamListInfo boundParams, ResourceOwner owner, QueryEnvironment queryEnv)

void	ReleaseCachedPlan (CachedPlan *plan, ResourceOwner owner)

bool	CachedPlanAllowsSimpleValidityCheck (CachedPlanSource plansource, CachedPlan plan, ResourceOwner owner)

bool	CachedPlanIsSimplyValid (CachedPlanSource plansource, CachedPlan plan, ResourceOwner owner)

void	CachedPlanSetParentContext (CachedPlanSource *plansource, MemoryContext newcontext)

CachedPlanSource *	CopyCachedPlan (CachedPlanSource *plansource)

bool	CachedPlanIsValid (CachedPlanSource *plansource)

List *	CachedPlanGetTargetList (CachedPlanSource plansource, QueryEnvironment queryEnv)

CachedExpression *	GetCachedExpression (Node *expr)

void	FreeCachedExpression (CachedExpression *cexpr)

void	ResetPlanCache (void)

void	ReleaseAllPlanCacheRefsInOwner (ResourceOwner owner)

Variables
static dlist_head	saved_plan_list = DLIST_STATIC_INIT(saved_plan_list)

static dlist_head	cached_expression_list = DLIST_STATIC_INIT(cached_expression_list)

static const ResourceOwnerDesc	planref_resowner_desc

int	plan_cache_mode = PLAN_CACHE_MODE_AUTO

Macro Definition Documentation

◆ StmtPlanRequiresRevalidation

#define StmtPlanRequiresRevalidation ( plansource )

Value:

((plansource)->raw_parse_tree != NULL && \

stmt_requires_parse_analysis((plansource)->raw_parse_tree))

stmt_requires_parse_analysis

bool stmt_requires_parse_analysis(RawStmt *parseTree)

Definition: analyze.c:532

Definition at line 85 of file plancache.c.

Function Documentation

◆ AcquireExecutorLocks()

static void AcquireExecutorLocks	(	List *	stmt_list,
		bool	acquire
	)

static

Definition at line 1916 of file plancache.c.

{
    ListCell   *lc1;
 
    foreach(lc1, stmt_list)
    {
        PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc1);
        int         rtindex;
 
        if (plannedstmt->commandType == CMD_UTILITY)
        {
            /*
             * Ignore utility statements, except those (such as EXPLAIN) that
             * contain a parsed-but-not-planned query.  Note: it's okay to use
             * ScanQueryForLocks, even though the query hasn't been through
             * rule rewriting, because rewriting doesn't change the query
             * representation.
             */
            Query      *query = UtilityContainsQuery(plannedstmt->utilityStmt);
 
            if (query)
                ScanQueryForLocks(query, acquire);
            continue;
        }
 
        rtindex = -1;
        while ((rtindex = bms_next_member(plannedstmt->unprunableRelids,
                                          rtindex)) >= 0)
        {
            RangeTblEntry *rte = list_nth_node(RangeTblEntry,
                                               plannedstmt->rtable,
                                               rtindex - 1);
 
            Assert(rte->rtekind == RTE_RELATION ||
                   (rte->rtekind == RTE_SUBQUERY && OidIsValid(rte->relid)));
 
            /*
             * Acquire the appropriate type of lock on each relation OID. Note
             * that we don't actually try to open the rel, and hence will not
             * fail if it's been dropped entirely --- we'll just transiently
             * acquire a non-conflicting lock.
             */
            if (acquire)
                LockRelationOid(rte->relid, rte->rellockmode);
            else
                UnlockRelationOid(rte->relid, rte->rellockmode);
        }
    }
}

References Assert(), bms_next_member(), CMD_UTILITY, PlannedStmt::commandType, lfirst_node, list_nth_node, LockRelationOid(), OidIsValid, RangeTblEntry::relid, PlannedStmt::rtable, RTE_RELATION, RTE_SUBQUERY, RangeTblEntry::rtekind, ScanQueryForLocks(), UnlockRelationOid(), PlannedStmt::unprunableRelids, UtilityContainsQuery(), and PlannedStmt::utilityStmt.

Referenced by CheckCachedPlan().

◆ AcquirePlannerLocks()

static void AcquirePlannerLocks	(	List *	stmt_list,
		bool	acquire
	)

static

Definition at line 1975 of file plancache.c.

{
    ListCell   *lc;
 
    foreach(lc, stmt_list)
    {
        Query      *query = lfirst_node(Query, lc);
 
        if (query->commandType == CMD_UTILITY)
        {
            /* Ignore utility statements, unless they contain a Query */
            query = UtilityContainsQuery(query->utilityStmt);
            if (query)
                ScanQueryForLocks(query, acquire);
            continue;
        }
 
        ScanQueryForLocks(query, acquire);
    }
}

References CMD_UTILITY, Query::commandType, lfirst_node, ScanQueryForLocks(), UtilityContainsQuery(), and Query::utilityStmt.

Referenced by RevalidateCachedQuery().

◆ BuildCachedPlan()

static CachedPlan * BuildCachedPlan	(	CachedPlanSource *	plansource,
		List *	qlist,
		ParamListInfo	boundParams,
		QueryEnvironment *	queryEnv
	)

static

Definition at line 919 of file plancache.c.

{
    CachedPlan *plan;
    List       *plist;
    bool        snapshot_set;
    bool        is_transient;
    MemoryContext plan_context;
    MemoryContext stmt_context = NULL;
    MemoryContext oldcxt = CurrentMemoryContext;
    ListCell   *lc;
 
    /*
     * Normally the querytree should be valid already, but if it's not,
     * rebuild it.
     *
     * NOTE: GetCachedPlan should have called RevalidateCachedQuery first, so
     * we ought to be holding sufficient locks to prevent any invalidation.
     * However, if we're building a custom plan after having built and
     * rejected a generic plan, it's possible to reach here with is_valid
     * false due to an invalidation while making the generic plan.  In theory
     * the invalidation must be a false positive, perhaps a consequence of an
     * sinval reset event or the debug_discard_caches code.  But for safety,
     * let's treat it as real and redo the RevalidateCachedQuery call.
     */
    if (!plansource->is_valid)
        qlist = RevalidateCachedQuery(plansource, queryEnv, true);
 
    /*
     * If we don't already have a copy of the querytree list that can be
     * scribbled on by the planner, make one.  For a one-shot plan, we assume
     * it's okay to scribble on the original query_list.
     */
    if (qlist == NIL)
    {
        if (!plansource->is_oneshot)
            qlist = copyObject(plansource->query_list);
        else
            qlist = plansource->query_list;
    }
 
    /*
     * If a snapshot is already set (the normal case), we can just use that
     * for planning.  But if it isn't, and we need one, install one.
     */
    snapshot_set = false;
    if (!ActiveSnapshotSet() &&
        plansource->raw_parse_tree &&
        analyze_requires_snapshot(plansource->raw_parse_tree))
    {
        PushActiveSnapshot(GetTransactionSnapshot());
        snapshot_set = true;
    }
 
    /*
     * Generate the plan.
     */
    plist = pg_plan_queries(qlist, plansource->query_string,
                            plansource->cursor_options, boundParams);
 
    /* Release snapshot if we got one */
    if (snapshot_set)
        PopActiveSnapshot();
 
    /*
     * Normally, we create a dedicated memory context for the CachedPlan and
     * its subsidiary data. Although it's usually not very large, the context
     * is designed to allow growth if necessary.
     *
     * The PlannedStmts are stored in a separate child context (stmt_context)
     * of the CachedPlan's memory context. This separation allows
     * UpdateCachedPlan() to free and replace the PlannedStmts without
     * affecting the CachedPlan structure or its stmt_list List.
     *
     * For one-shot plans, we instead use the caller's memory context, as the
     * CachedPlan will not persist.  stmt_context will be set to NULL in this
     * case, because UpdateCachedPlan() should never get called on a one-shot
     * plan.
     */
    if (!plansource->is_oneshot)
    {
        plan_context = AllocSetContextCreate(CurrentMemoryContext,
                                             "CachedPlan",
                                             ALLOCSET_START_SMALL_SIZES);
        MemoryContextCopyAndSetIdentifier(plan_context, plansource->query_string);
 
        stmt_context = AllocSetContextCreate(CurrentMemoryContext,
                                             "CachedPlan PlannedStmts",
                                             ALLOCSET_START_SMALL_SIZES);
        MemoryContextCopyAndSetIdentifier(stmt_context, plansource->query_string);
        MemoryContextSetParent(stmt_context, plan_context);
 
        MemoryContextSwitchTo(stmt_context);
        plist = copyObject(plist);
 
        MemoryContextSwitchTo(plan_context);
        plist = list_copy(plist);
    }
    else
        plan_context = CurrentMemoryContext;
 
    /*
     * Create and fill the CachedPlan struct within the new context.
     */
    plan = (CachedPlan *) palloc(sizeof(CachedPlan));
    plan->magic = CACHEDPLAN_MAGIC;
    plan->stmt_list = plist;
 
    /*
     * CachedPlan is dependent on role either if RLS affected the rewrite
     * phase or if a role dependency was injected during planning.  And it's
     * transient if any plan is marked so.
     */
    plan->planRoleId = GetUserId();
    plan->dependsOnRole = plansource->dependsOnRLS;
    is_transient = false;
    foreach(lc, plist)
    {
        PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
 
        if (plannedstmt->commandType == CMD_UTILITY)
            continue;           /* Ignore utility statements */
 
        if (plannedstmt->transientPlan)
            is_transient = true;
        if (plannedstmt->dependsOnRole)
            plan->dependsOnRole = true;
    }
    if (is_transient)
    {
        Assert(TransactionIdIsNormal(TransactionXmin));
        plan->saved_xmin = TransactionXmin;
    }
    else
        plan->saved_xmin = InvalidTransactionId;
    plan->refcount = 0;
    plan->context = plan_context;
    plan->stmt_context = stmt_context;
    plan->is_oneshot = plansource->is_oneshot;
    plan->is_saved = false;
    plan->is_reused = false;
    plan->is_valid = true;
 
    /* assign generation number to new plan */
    plan->generation = ++(plansource->generation);
 
    MemoryContextSwitchTo(oldcxt);
 
    return plan;
}

References ActiveSnapshotSet(), ALLOCSET_START_SMALL_SIZES, AllocSetContextCreate, analyze_requires_snapshot(), Assert(), CACHEDPLAN_MAGIC, CMD_UTILITY, PlannedStmt::commandType, copyObject, CurrentMemoryContext, CachedPlanSource::cursor_options, CachedPlanSource::dependsOnRLS, PlannedStmt::dependsOnRole, CachedPlanSource::generation, GetTransactionSnapshot(), GetUserId(), InvalidTransactionId, CachedPlanSource::is_oneshot, CachedPlanSource::is_valid, lfirst_node, list_copy(), MemoryContextCopyAndSetIdentifier, MemoryContextSetParent(), MemoryContextSwitchTo(), NIL, palloc(), pg_plan_queries(), plan, PopActiveSnapshot(), PushActiveSnapshot(), CachedPlanSource::query_list, CachedPlanSource::query_string, CachedPlanSource::raw_parse_tree, RevalidateCachedQuery(), TransactionIdIsNormal, TransactionXmin, and PlannedStmt::transientPlan.

Referenced by GetCachedPlan().

◆ cached_plan_cost()

static double cached_plan_cost	(	CachedPlan *	plan,
		bool	include_planner
	)

static

Definition at line 1240 of file plancache.c.

{
    double      result = 0;
    ListCell   *lc;
 
    foreach(lc, plan->stmt_list)
    {
        PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
 
        if (plannedstmt->commandType == CMD_UTILITY)
            continue;           /* Ignore utility statements */
 
        result += plannedstmt->planTree->total_cost;
 
        if (include_planner)
        {
            /*
             * Currently we use a very crude estimate of planning effort based
             * on the number of relations in the finished plan's rangetable.
             * Join planning effort actually scales much worse than linearly
             * in the number of relations --- but only until the join collapse
             * limits kick in.  Also, while inheritance child relations surely
             * add to planning effort, they don't make the join situation
             * worse.  So the actual shape of the planning cost curve versus
             * number of relations isn't all that obvious.  It will take
             * considerable work to arrive at a less crude estimate, and for
             * now it's not clear that's worth doing.
             *
             * The other big difficulty here is that we don't have any very
             * good model of how planning cost compares to execution costs.
             * The current multiplier of 1000 * cpu_operator_cost is probably
             * on the low side, but we'll try this for awhile before making a
             * more aggressive correction.
             *
             * If we ever do write a more complicated estimator, it should
             * probably live in src/backend/optimizer/ not here.
             */
            int         nrelations = list_length(plannedstmt->rtable);
 
            result += 1000.0 * cpu_operator_cost * (nrelations + 1);
        }
    }
 
    return result;
}

References CMD_UTILITY, PlannedStmt::commandType, cpu_operator_cost, lfirst_node, list_length(), plan, PlannedStmt::planTree, PlannedStmt::rtable, and Plan::total_cost.

Referenced by GetCachedPlan(), and UpdateCachedPlan().

◆ CachedPlanAllowsSimpleValidityCheck()

bool CachedPlanAllowsSimpleValidityCheck	(	CachedPlanSource *	plansource,
		CachedPlan *	plan,
		ResourceOwner	owner
	)

Definition at line 1480 of file plancache.c.

{
    ListCell   *lc;
 
    /*
     * Sanity-check that the caller gave us a validated generic plan.  Notice
     * that we *don't* assert plansource->is_valid as you might expect; that's
     * because it's possible that that's already false when GetCachedPlan
     * returns, e.g. because ResetPlanCache happened partway through.  We
     * should accept the plan as long as plan->is_valid is true, and expect to
     * replan after the next CachedPlanIsSimplyValid call.
     */
    Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
    Assert(plan->magic == CACHEDPLAN_MAGIC);
    Assert(plan->is_valid);
    Assert(plan == plansource->gplan);
    Assert(plansource->search_path != NULL);
    Assert(SearchPathMatchesCurrentEnvironment(plansource->search_path));
 
    /* We don't support oneshot plans here. */
    if (plansource->is_oneshot)
        return false;
    Assert(!plan->is_oneshot);
 
    /*
     * If the plan is dependent on RLS considerations, or it's transient,
     * reject.  These things probably can't ever happen for table-free
     * queries, but for safety's sake let's check.
     */
    if (plansource->dependsOnRLS)
        return false;
    if (plan->dependsOnRole)
        return false;
    if (TransactionIdIsValid(plan->saved_xmin))
        return false;
 
    /*
     * Reject if AcquirePlannerLocks would have anything to do.  This is
     * simplistic, but there's no need to inquire any more carefully; indeed,
     * for current callers it shouldn't even be possible to hit any of these
     * checks.
     */
    foreach(lc, plansource->query_list)
    {
        Query      *query = lfirst_node(Query, lc);
 
        if (query->commandType == CMD_UTILITY)
            return false;
        if (query->rtable || query->cteList || query->hasSubLinks)
            return false;
    }
 
    /*
     * Reject if AcquireExecutorLocks would have anything to do.  This is
     * probably unnecessary given the previous check, but let's be safe.
     */
    foreach(lc, plan->stmt_list)
    {
        PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
        ListCell   *lc2;
 
        if (plannedstmt->commandType == CMD_UTILITY)
            return false;
 
        /*
         * We have to grovel through the rtable because it's likely to contain
         * an RTE_RESULT relation, rather than being totally empty.
         */
        foreach(lc2, plannedstmt->rtable)
        {
            RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc2);
 
            if (rte->rtekind == RTE_RELATION)
                return false;
        }
    }
 
    /*
     * Okay, it's simple.  Note that what we've primarily established here is
     * that no locks need be taken before checking the plan's is_valid flag.
     */
 
    /* Bump refcount if requested. */
    if (owner)
    {
        ResourceOwnerEnlarge(owner);
        plan->refcount++;
        ResourceOwnerRememberPlanCacheRef(owner, plan);
    }
 
    return true;
}

References Assert(), CACHEDPLAN_MAGIC, CACHEDPLANSOURCE_MAGIC, CMD_UTILITY, Query::commandType, PlannedStmt::commandType, Query::cteList, CachedPlanSource::dependsOnRLS, CachedPlanSource::gplan, CachedPlanSource::is_oneshot, lfirst, lfirst_node, CachedPlanSource::magic, plan, CachedPlanSource::query_list, ResourceOwnerEnlarge(), ResourceOwnerRememberPlanCacheRef(), Query::rtable, PlannedStmt::rtable, RTE_RELATION, RangeTblEntry::rtekind, CachedPlanSource::search_path, SearchPathMatchesCurrentEnvironment(), and TransactionIdIsValid.

Referenced by exec_eval_simple_expr(), and exec_simple_check_plan().

◆ CachedPlanGetTargetList()

List * CachedPlanGetTargetList	(	CachedPlanSource *	plansource,
		QueryEnvironment *	queryEnv
	)

Definition at line 1784 of file plancache.c.

{
    Query      *pstmt;
 
    /* Assert caller is doing things in a sane order */
    Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
    Assert(plansource->is_complete);
 
    /*
     * No work needed if statement doesn't return tuples (we assume this
     * feature cannot be changed by an invalidation)
     */
    if (plansource->resultDesc == NULL)
        return NIL;
 
    /* Make sure the querytree list is valid and we have parse-time locks */
    RevalidateCachedQuery(plansource, queryEnv, true);
 
    /* Get the primary statement and find out what it returns */
    pstmt = QueryListGetPrimaryStmt(plansource->query_list);
 
    return FetchStatementTargetList((Node *) pstmt);
}

References Assert(), CACHEDPLANSOURCE_MAGIC, FetchStatementTargetList(), CachedPlanSource::is_complete, CachedPlanSource::magic, NIL, CachedPlanSource::query_list, QueryListGetPrimaryStmt(), CachedPlanSource::resultDesc, and RevalidateCachedQuery().

Referenced by exec_describe_statement_message(), and FetchPreparedStatementTargetList().

◆ CachedPlanIsSimplyValid()

bool CachedPlanIsSimplyValid	(	CachedPlanSource *	plansource,
		CachedPlan *	plan,
		ResourceOwner	owner
	)

Definition at line 1595 of file plancache.c.

{
    /*
     * Careful here: since the caller doesn't necessarily hold a refcount on
     * the plan to start with, it's possible that "plan" is a dangling
     * pointer.  Don't dereference it until we've verified that it still
     * matches the plansource's gplan (which is either valid or NULL).
     */
    Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
 
    /*
     * Has cache invalidation fired on this plan?  We can check this right
     * away since there are no locks that we'd need to acquire first.  Note
     * that here we *do* check plansource->is_valid, so as to force plan
     * rebuild if that's become false.
     */
    if (!plansource->is_valid ||
        plan == NULL || plan != plansource->gplan ||
        !plan->is_valid)
        return false;
 
    Assert(plan->magic == CACHEDPLAN_MAGIC);
 
    /* Is the search_path still the same as when we made it? */
    Assert(plansource->search_path != NULL);
    if (!SearchPathMatchesCurrentEnvironment(plansource->search_path))
        return false;
 
    /* It's still good.  Bump refcount if requested. */
    if (owner)
    {
        ResourceOwnerEnlarge(owner);
        plan->refcount++;
        ResourceOwnerRememberPlanCacheRef(owner, plan);
    }
 
    return true;
}

References Assert(), CACHEDPLAN_MAGIC, CACHEDPLANSOURCE_MAGIC, CachedPlanSource::gplan, CachedPlanSource::is_valid, CachedPlanSource::magic, plan, ResourceOwnerEnlarge(), ResourceOwnerRememberPlanCacheRef(), CachedPlanSource::search_path, and SearchPathMatchesCurrentEnvironment().

Referenced by exec_eval_simple_expr().

◆ CachedPlanIsValid()

bool CachedPlanIsValid ( CachedPlanSource * plansource )

Definition at line 1771 of file plancache.c.

{
    Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
    return plansource->is_valid;
}

References Assert(), CACHEDPLANSOURCE_MAGIC, CachedPlanSource::is_valid, and CachedPlanSource::magic.

Referenced by SPI_plan_is_valid().

◆ CachedPlanSetParentContext()

void CachedPlanSetParentContext	(	CachedPlanSource *	plansource,
		MemoryContext	newcontext
	)

Definition at line 1642 of file plancache.c.

{
    /* Assert caller is doing things in a sane order */
    Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
    Assert(plansource->is_complete);
 
    /* These seem worth real tests, though */
    if (plansource->is_saved)
        elog(ERROR, "cannot move a saved cached plan to another context");
    if (plansource->is_oneshot)
        elog(ERROR, "cannot move a one-shot cached plan to another context");
 
    /* OK, let the caller keep the plan where he wishes */
    MemoryContextSetParent(plansource->context, newcontext);
 
    /*
     * The query_context needs no special handling, since it's a child of
     * plansource->context.  But if there's a generic plan, it should be
     * maintained as a sibling of plansource->context.
     */
    if (plansource->gplan)
    {
        Assert(plansource->gplan->magic == CACHEDPLAN_MAGIC);
        MemoryContextSetParent(plansource->gplan->context, newcontext);
    }
}

References Assert(), CACHEDPLAN_MAGIC, CACHEDPLANSOURCE_MAGIC, CachedPlanSource::context, CachedPlan::context, elog, ERROR, CachedPlanSource::gplan, CachedPlanSource::is_complete, CachedPlanSource::is_oneshot, CachedPlanSource::is_saved, CachedPlanSource::magic, CachedPlan::magic, and MemoryContextSetParent().

Referenced by _SPI_make_plan_non_temp().

◆ CheckCachedPlan()

static bool CheckCachedPlan ( CachedPlanSource * plansource )

static

Definition at line 833 of file plancache.c.

{
    CachedPlan *plan = plansource->gplan;
 
    /* Assert that caller checked the querytree */
    Assert(plansource->is_valid);
 
    /* If there's no generic plan, just say "false" */
    if (!plan)
        return false;
 
    Assert(plan->magic == CACHEDPLAN_MAGIC);
    /* Generic plans are never one-shot */
    Assert(!plan->is_oneshot);
 
    /*
     * If plan isn't valid for current role, we can't use it.
     */
    if (plan->is_valid && plan->dependsOnRole &&
        plan->planRoleId != GetUserId())
        plan->is_valid = false;
 
    /*
     * If it appears valid, acquire locks and recheck; this is much the same
     * logic as in RevalidateCachedQuery, but for a plan.
     */
    if (plan->is_valid)
    {
        /*
         * Plan must have positive refcount because it is referenced by
         * plansource; so no need to fear it disappears under us here.
         */
        Assert(plan->refcount > 0);
 
        AcquireExecutorLocks(plan->stmt_list, true);
 
        /*
         * If plan was transient, check to see if TransactionXmin has
         * advanced, and if so invalidate it.
         */
        if (plan->is_valid &&
            TransactionIdIsValid(plan->saved_xmin) &&
            !TransactionIdEquals(plan->saved_xmin, TransactionXmin))
            plan->is_valid = false;
 
        /*
         * By now, if any invalidation has happened, the inval callback
         * functions will have marked the plan invalid.
         */
        if (plan->is_valid)
        {
            /* Successfully revalidated and locked the query. */
            return true;
        }
 
        /* Oops, the race case happened.  Release useless locks. */
        AcquireExecutorLocks(plan->stmt_list, false);
    }
 
    /*
     * Plan has been invalidated, so unlink it from the parent and release it.
     */
    ReleaseGenericPlan(plansource);
 
    return false;
}

References AcquireExecutorLocks(), Assert(), CACHEDPLAN_MAGIC, GetUserId(), CachedPlanSource::gplan, CachedPlanSource::is_valid, plan, ReleaseGenericPlan(), TransactionIdEquals, TransactionIdIsValid, and TransactionXmin.

Referenced by GetCachedPlan().

◆ choose_custom_plan()

static bool choose_custom_plan	(	CachedPlanSource *	plansource,
		ParamListInfo	boundParams
	)

static

Definition at line 1183 of file plancache.c.

{
    double      avg_custom_cost;
 
    /* One-shot plans will always be considered custom */
    if (plansource->is_oneshot)
        return true;
 
    /* Otherwise, never any point in a custom plan if there's no parameters */
    if (boundParams == NULL)
        return false;
    /* ... nor when planning would be a no-op */
    if (!StmtPlanRequiresRevalidation(plansource))
        return false;
 
    /* Let settings force the decision */
    if (plan_cache_mode == PLAN_CACHE_MODE_FORCE_GENERIC_PLAN)
        return false;
    if (plan_cache_mode == PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN)
        return true;
 
    /* See if caller wants to force the decision */
    if (plansource->cursor_options & CURSOR_OPT_GENERIC_PLAN)
        return false;
    if (plansource->cursor_options & CURSOR_OPT_CUSTOM_PLAN)
        return true;
 
    /* Generate custom plans until we have done at least 5 (arbitrary) */
    if (plansource->num_custom_plans < 5)
        return true;
 
    avg_custom_cost = plansource->total_custom_cost / plansource->num_custom_plans;
 
    /*
     * Prefer generic plan if it's less expensive than the average custom
     * plan.  (Because we include a charge for cost of planning in the
     * custom-plan costs, this means the generic plan only has to be less
     * expensive than the execution cost plus replan cost of the custom
     * plans.)
     *
     * Note that if generic_cost is -1 (indicating we've not yet determined
     * the generic plan cost), we'll always prefer generic at this point.
     */
    if (plansource->generic_cost < avg_custom_cost)
        return false;
 
    return true;
}

References CURSOR_OPT_CUSTOM_PLAN, CURSOR_OPT_GENERIC_PLAN, CachedPlanSource::cursor_options, CachedPlanSource::generic_cost, CachedPlanSource::is_oneshot, CachedPlanSource::num_custom_plans, plan_cache_mode, PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN, PLAN_CACHE_MODE_FORCE_GENERIC_PLAN, StmtPlanRequiresRevalidation, and CachedPlanSource::total_custom_cost.

Referenced by GetCachedPlan().

◆ CompleteCachedPlan()

void CompleteCachedPlan	(	CachedPlanSource *	plansource,
		List *	querytree_list,
		MemoryContext	querytree_context,
		Oid *	param_types,
		int	num_params,
		ParserSetupHook	parserSetup,
		void *	parserSetupArg,
		int	cursor_options,
		bool	fixed_result
	)

Definition at line 367 of file plancache.c.

{
    MemoryContext source_context = plansource->context;
    MemoryContext oldcxt = CurrentMemoryContext;
 
    /* Assert caller is doing things in a sane order */
    Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
    Assert(!plansource->is_complete);
 
    /*
     * If caller supplied a querytree_context, reparent it underneath the
     * CachedPlanSource's context; otherwise, create a suitable context and
     * copy the querytree_list into it.  But no data copying should be done
     * for one-shot plans; for those, assume the passed querytree_list is
     * sufficiently long-lived.
     */
    if (plansource->is_oneshot)
    {
        querytree_context = CurrentMemoryContext;
    }
    else if (querytree_context != NULL)
    {
        MemoryContextSetParent(querytree_context, source_context);
        MemoryContextSwitchTo(querytree_context);
    }
    else
    {
        /* Again, it's a good bet the querytree_context can be small */
        querytree_context = AllocSetContextCreate(source_context,
                                                  "CachedPlanQuery",
                                                  ALLOCSET_START_SMALL_SIZES);
        MemoryContextSwitchTo(querytree_context);
        querytree_list = copyObject(querytree_list);
    }
 
    plansource->query_context = querytree_context;
    plansource->query_list = querytree_list;
 
    if (!plansource->is_oneshot && StmtPlanRequiresRevalidation(plansource))
    {
        /*
         * Use the planner machinery to extract dependencies.  Data is saved
         * in query_context.  (We assume that not a lot of extra cruft is
         * created by this call.)  We can skip this for one-shot plans, and
         * plans not needing revalidation have no such dependencies anyway.
         */
        extract_query_dependencies((Node *) querytree_list,
                                   &plansource->relationOids,
                                   &plansource->invalItems,
                                   &plansource->dependsOnRLS);
 
        /* Update RLS info as well. */
        plansource->rewriteRoleId = GetUserId();
        plansource->rewriteRowSecurity = row_security;
 
        /*
         * Also save the current search_path in the query_context.  (This
         * should not generate much extra cruft either, since almost certainly
         * the path is already valid.)  Again, we don't really need this for
         * one-shot plans; and we *must* skip this for transaction control
         * commands, because this could result in catalog accesses.
         */
        plansource->search_path = GetSearchPathMatcher(querytree_context);
    }
 
    /*
     * Save the final parameter types (or other parameter specification data)
     * into the source_context, as well as our other parameters.  Also save
     * the result tuple descriptor.
     */
    MemoryContextSwitchTo(source_context);
 
    if (num_params > 0)
    {
        plansource->param_types = (Oid *) palloc(num_params * sizeof(Oid));
        memcpy(plansource->param_types, param_types, num_params * sizeof(Oid));
    }
    else
        plansource->param_types = NULL;
    plansource->num_params = num_params;
    plansource->parserSetup = parserSetup;
    plansource->parserSetupArg = parserSetupArg;
    plansource->cursor_options = cursor_options;
    plansource->fixed_result = fixed_result;
    plansource->resultDesc = PlanCacheComputeResultDesc(querytree_list);
 
    MemoryContextSwitchTo(oldcxt);
 
    plansource->is_complete = true;
    plansource->is_valid = true;
}

Referenced by _SPI_execute_plan(), _SPI_prepare_plan(), exec_parse_message(), and PrepareQuery().

◆ CopyCachedPlan()

CachedPlanSource * CopyCachedPlan ( CachedPlanSource * plansource )

Definition at line 1680 of file plancache.c.

{
    CachedPlanSource *newsource;
    MemoryContext source_context;
    MemoryContext querytree_context;
    MemoryContext oldcxt;
 
    Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
    Assert(plansource->is_complete);
 
    /*
     * One-shot plans can't be copied, because we haven't taken care that
     * parsing/planning didn't scribble on the raw parse tree or querytrees.
     */
    if (plansource->is_oneshot)
        elog(ERROR, "cannot copy a one-shot cached plan");
 
    source_context = AllocSetContextCreate(CurrentMemoryContext,
                                           "CachedPlanSource",
                                           ALLOCSET_START_SMALL_SIZES);
 
    oldcxt = MemoryContextSwitchTo(source_context);
 
    newsource = (CachedPlanSource *) palloc0(sizeof(CachedPlanSource));
    newsource->magic = CACHEDPLANSOURCE_MAGIC;
    newsource->raw_parse_tree = copyObject(plansource->raw_parse_tree);
    newsource->query_string = pstrdup(plansource->query_string);
    MemoryContextSetIdentifier(source_context, newsource->query_string);
    newsource->commandTag = plansource->commandTag;
    if (plansource->num_params > 0)
    {
        newsource->param_types = (Oid *)
            palloc(plansource->num_params * sizeof(Oid));
        memcpy(newsource->param_types, plansource->param_types,
               plansource->num_params * sizeof(Oid));
    }
    else
        newsource->param_types = NULL;
    newsource->num_params = plansource->num_params;
    newsource->parserSetup = plansource->parserSetup;
    newsource->parserSetupArg = plansource->parserSetupArg;
    newsource->cursor_options = plansource->cursor_options;
    newsource->fixed_result = plansource->fixed_result;
    if (plansource->resultDesc)
        newsource->resultDesc = CreateTupleDescCopy(plansource->resultDesc);
    else
        newsource->resultDesc = NULL;
    newsource->context = source_context;
 
    querytree_context = AllocSetContextCreate(source_context,
                                              "CachedPlanQuery",
                                              ALLOCSET_START_SMALL_SIZES);
    MemoryContextSwitchTo(querytree_context);
    newsource->query_list = copyObject(plansource->query_list);
    newsource->relationOids = copyObject(plansource->relationOids);
    newsource->invalItems = copyObject(plansource->invalItems);
    if (plansource->search_path)
        newsource->search_path = CopySearchPathMatcher(plansource->search_path);
    newsource->query_context = querytree_context;
    newsource->rewriteRoleId = plansource->rewriteRoleId;
    newsource->rewriteRowSecurity = plansource->rewriteRowSecurity;
    newsource->dependsOnRLS = plansource->dependsOnRLS;
 
    newsource->gplan = NULL;
 
    newsource->is_oneshot = false;
    newsource->is_complete = true;
    newsource->is_saved = false;
    newsource->is_valid = plansource->is_valid;
    newsource->generation = plansource->generation;
 
    /* We may as well copy any acquired cost knowledge */
    newsource->generic_cost = plansource->generic_cost;
    newsource->total_custom_cost = plansource->total_custom_cost;
    newsource->num_generic_plans = plansource->num_generic_plans;
    newsource->num_custom_plans = plansource->num_custom_plans;
 
    MemoryContextSwitchTo(oldcxt);
 
    return newsource;
}

Referenced by _SPI_save_plan().

◆ CreateCachedPlan()

CachedPlanSource * CreateCachedPlan	(	RawStmt *	raw_parse_tree,
		const char *	query_string,
		CommandTag	commandTag
	)

Definition at line 193 of file plancache.c.

{
    CachedPlanSource *plansource;
    MemoryContext source_context;
    MemoryContext oldcxt;
 
    Assert(query_string != NULL);   /* required as of 8.4 */
 
    /*
     * Make a dedicated memory context for the CachedPlanSource and its
     * permanent subsidiary data.  It's probably not going to be large, but
     * just in case, allow it to grow large.  Initially it's a child of the
     * caller's context (which we assume to be transient), so that it will be
     * cleaned up on error.
     */
    source_context = AllocSetContextCreate(CurrentMemoryContext,
                                           "CachedPlanSource",
                                           ALLOCSET_START_SMALL_SIZES);
 
    /*
     * Create and fill the CachedPlanSource struct within the new context.
     * Most fields are just left empty for the moment.
     */
    oldcxt = MemoryContextSwitchTo(source_context);
 
    plansource = (CachedPlanSource *) palloc0(sizeof(CachedPlanSource));
    plansource->magic = CACHEDPLANSOURCE_MAGIC;
    plansource->raw_parse_tree = copyObject(raw_parse_tree);
    plansource->query_string = pstrdup(query_string);
    MemoryContextSetIdentifier(source_context, plansource->query_string);
    plansource->commandTag = commandTag;
    plansource->param_types = NULL;
    plansource->num_params = 0;
    plansource->parserSetup = NULL;
    plansource->parserSetupArg = NULL;
    plansource->cursor_options = 0;
    plansource->fixed_result = false;
    plansource->resultDesc = NULL;
    plansource->context = source_context;
    plansource->query_list = NIL;
    plansource->relationOids = NIL;
    plansource->invalItems = NIL;
    plansource->search_path = NULL;
    plansource->query_context = NULL;
    plansource->rewriteRoleId = InvalidOid;
    plansource->rewriteRowSecurity = false;
    plansource->dependsOnRLS = false;
    plansource->gplan = NULL;
    plansource->is_oneshot = false;
    plansource->is_complete = false;
    plansource->is_saved = false;
    plansource->is_valid = false;
    plansource->generation = 0;
    plansource->generic_cost = -1;
    plansource->total_custom_cost = 0;
    plansource->num_generic_plans = 0;
    plansource->num_custom_plans = 0;
 
    MemoryContextSwitchTo(oldcxt);
 
    return plansource;
}

Referenced by _SPI_prepare_plan(), exec_parse_message(), and PrepareQuery().

◆ CreateOneShotCachedPlan()

CachedPlanSource * CreateOneShotCachedPlan	(	RawStmt *	raw_parse_tree,
		const char *	query_string,
		CommandTag	commandTag
	)

Definition at line 277 of file plancache.c.

{
    CachedPlanSource *plansource;
 
    Assert(query_string != NULL);   /* required as of 8.4 */
 
    /*
     * Create and fill the CachedPlanSource struct within the caller's memory
     * context.  Most fields are just left empty for the moment.
     */
    plansource = (CachedPlanSource *) palloc0(sizeof(CachedPlanSource));
    plansource->magic = CACHEDPLANSOURCE_MAGIC;
    plansource->raw_parse_tree = raw_parse_tree;
    plansource->query_string = query_string;
    plansource->commandTag = commandTag;
    plansource->param_types = NULL;
    plansource->num_params = 0;
    plansource->parserSetup = NULL;
    plansource->parserSetupArg = NULL;
    plansource->cursor_options = 0;
    plansource->fixed_result = false;
    plansource->resultDesc = NULL;
    plansource->context = CurrentMemoryContext;
    plansource->query_list = NIL;
    plansource->relationOids = NIL;
    plansource->invalItems = NIL;
    plansource->search_path = NULL;
    plansource->query_context = NULL;
    plansource->rewriteRoleId = InvalidOid;
    plansource->rewriteRowSecurity = false;
    plansource->dependsOnRLS = false;
    plansource->gplan = NULL;
    plansource->is_oneshot = true;
    plansource->is_complete = false;
    plansource->is_saved = false;
    plansource->is_valid = false;
    plansource->generation = 0;
    plansource->generic_cost = -1;
    plansource->total_custom_cost = 0;
    plansource->num_generic_plans = 0;
    plansource->num_custom_plans = 0;
 
    return plansource;
}

Referenced by _SPI_prepare_oneshot_plan().

◆ DropCachedPlan()

void DropCachedPlan ( CachedPlanSource * plansource )

Definition at line 527 of file plancache.c.

{
    Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
 
    /* If it's been saved, remove it from the list */
    if (plansource->is_saved)
    {
        dlist_delete(&plansource->node);
        plansource->is_saved = false;
    }
 
    /* Decrement generic CachedPlan's refcount and drop if no longer needed */
    ReleaseGenericPlan(plansource);
 
    /* Mark it no longer valid */
    plansource->magic = 0;
 
    /*
     * Remove the CachedPlanSource and all subsidiary data (including the
     * query_context if any).  But if it's a one-shot we can't free anything.
     */
    if (!plansource->is_oneshot)
        MemoryContextDelete(plansource->context);
}

References Assert(), CACHEDPLANSOURCE_MAGIC, CachedPlanSource::context, dlist_delete(), CachedPlanSource::is_oneshot, CachedPlanSource::is_saved, CachedPlanSource::magic, MemoryContextDelete(), CachedPlanSource::node, and ReleaseGenericPlan().

Referenced by drop_unnamed_stmt(), DropAllPreparedStatements(), DropPreparedStatement(), and SPI_freeplan().

◆ FreeCachedExpression()

void FreeCachedExpression ( CachedExpression * cexpr )

Definition at line 1878 of file plancache.c.

{
    /* Sanity check */
    Assert(cexpr->magic == CACHEDEXPR_MAGIC);
    /* Unlink from global list */
    dlist_delete(&cexpr->node);
    /* Free all storage associated with CachedExpression */
    MemoryContextDelete(cexpr->context);
}

References Assert(), CACHEDEXPR_MAGIC, CachedExpression::context, dlist_delete(), CachedExpression::magic, MemoryContextDelete(), and CachedExpression::node.

Referenced by get_cast_hashentry().

◆ GetCachedExpression()

CachedExpression * GetCachedExpression ( Node * expr )

Definition at line 1821 of file plancache.c.

{
    CachedExpression *cexpr;
    List       *relationOids;
    List       *invalItems;
    MemoryContext cexpr_context;
    MemoryContext oldcxt;
 
    /*
     * Pass the expression through the planner, and collect dependencies.
     * Everything built here is leaked in the caller's context; that's
     * intentional to minimize the size of the permanent data structure.
     */
    expr = (Node *) expression_planner_with_deps((Expr *) expr,
                                                 &relationOids,
                                                 &invalItems);
 
    /*
     * Make a private memory context, and copy what we need into that.  To
     * avoid leaking a long-lived context if we fail while copying data, we
     * initially make the context under the caller's context.
     */
    cexpr_context = AllocSetContextCreate(CurrentMemoryContext,
                                          "CachedExpression",
                                          ALLOCSET_SMALL_SIZES);
 
    oldcxt = MemoryContextSwitchTo(cexpr_context);
 
    cexpr = (CachedExpression *) palloc(sizeof(CachedExpression));
    cexpr->magic = CACHEDEXPR_MAGIC;
    cexpr->expr = copyObject(expr);
    cexpr->is_valid = true;
    cexpr->relationOids = copyObject(relationOids);
    cexpr->invalItems = copyObject(invalItems);
    cexpr->context = cexpr_context;
 
    MemoryContextSwitchTo(oldcxt);
 
    /*
     * Reparent the expr's memory context under CacheMemoryContext so that it
     * will live indefinitely.
     */
    MemoryContextSetParent(cexpr_context, CacheMemoryContext);
 
    /*
     * Add the entry to the global list of cached expressions.
     */
    dlist_push_tail(&cached_expression_list, &cexpr->node);
 
    return cexpr;
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, cached_expression_list, CACHEDEXPR_MAGIC, CacheMemoryContext, CachedExpression::context, copyObject, CurrentMemoryContext, dlist_push_tail(), CachedExpression::expr, expression_planner_with_deps(), CachedExpression::invalItems, CachedExpression::is_valid, CachedExpression::magic, MemoryContextSetParent(), MemoryContextSwitchTo(), CachedExpression::node, palloc(), and CachedExpression::relationOids.

Referenced by get_cast_hashentry().

◆ GetCachedPlan()

CachedPlan * GetCachedPlan	(	CachedPlanSource *	plansource,
		ParamListInfo	boundParams,
		ResourceOwner	owner,
		QueryEnvironment *	queryEnv
	)

Definition at line 1310 of file plancache.c.

{
    CachedPlan *plan = NULL;
    List       *qlist;
    bool        customplan;
 
    /* Assert caller is doing things in a sane order */
    Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
    Assert(plansource->is_complete);
    /* This seems worth a real test, though */
    if (owner && !plansource->is_saved)
        elog(ERROR, "cannot apply ResourceOwner to non-saved cached plan");
 
    /* Make sure the querytree list is valid and we have parse-time locks */
    qlist = RevalidateCachedQuery(plansource, queryEnv, true);
 
    /* Decide whether to use a custom plan */
    customplan = choose_custom_plan(plansource, boundParams);
 
    if (!customplan)
    {
        if (CheckCachedPlan(plansource))
        {
            /* We want a generic plan, and we already have a valid one */
            plan = plansource->gplan;
            Assert(plan->magic == CACHEDPLAN_MAGIC);
            /* Reusing the existing plan, so not all locks may be acquired. */
            plan->is_reused = true;
        }
        else
        {
            /* Build a new generic plan */
            plan = BuildCachedPlan(plansource, qlist, NULL, queryEnv);
            /* Just make real sure plansource->gplan is clear */
            ReleaseGenericPlan(plansource);
            /* Link the new generic plan into the plansource */
            plansource->gplan = plan;
            plan->refcount++;
            /* Immediately reparent into appropriate context */
            if (plansource->is_saved)
            {
                /* saved plans all live under CacheMemoryContext */
                MemoryContextSetParent(plan->context, CacheMemoryContext);
                plan->is_saved = true;
            }
            else
            {
                /* otherwise, it should be a sibling of the plansource */
                MemoryContextSetParent(plan->context,
                                       MemoryContextGetParent(plansource->context));
            }
            /* Update generic_cost whenever we make a new generic plan */
            plansource->generic_cost = cached_plan_cost(plan, false);
 
            /*
             * If, based on the now-known value of generic_cost, we'd not have
             * chosen to use a generic plan, then forget it and make a custom
             * plan.  This is a bit of a wart but is necessary to avoid a
             * glitch in behavior when the custom plans are consistently big
             * winners; at some point we'll experiment with a generic plan and
             * find it's a loser, but we don't want to actually execute that
             * plan.
             */
            customplan = choose_custom_plan(plansource, boundParams);
 
            /*
             * If we choose to plan again, we need to re-copy the query_list,
             * since the planner probably scribbled on it.  We can force
             * BuildCachedPlan to do that by passing NIL.
             */
            qlist = NIL;
        }
    }
 
    if (customplan)
    {
        /* Build a custom plan */
        plan = BuildCachedPlan(plansource, qlist, boundParams, queryEnv);
        /* Accumulate total costs of custom plans */
        plansource->total_custom_cost += cached_plan_cost(plan, true);
 
        plansource->num_custom_plans++;
    }
    else
    {
        plansource->num_generic_plans++;
    }
 
    Assert(plan != NULL);
 
    /* Flag the plan as in use by caller */
    if (owner)
        ResourceOwnerEnlarge(owner);
    plan->refcount++;
    if (owner)
        ResourceOwnerRememberPlanCacheRef(owner, plan);
 
    /*
     * Saved plans should be under CacheMemoryContext so they will not go away
     * until their reference count goes to zero.  In the generic-plan cases we
     * already took care of that, but for a custom plan, do it as soon as we
     * have created a reference-counted link.
     */
    if (customplan && plansource->is_saved)
    {
        MemoryContextSetParent(plan->context, CacheMemoryContext);
        plan->is_saved = true;
    }
 
    return plan;
}

References Assert(), BuildCachedPlan(), cached_plan_cost(), CACHEDPLAN_MAGIC, CACHEDPLANSOURCE_MAGIC, CacheMemoryContext, CheckCachedPlan(), choose_custom_plan(), CachedPlanSource::context, elog, ERROR, CachedPlanSource::generic_cost, CachedPlanSource::gplan, CachedPlanSource::is_complete, CachedPlanSource::is_saved, CachedPlanSource::magic, MemoryContextGetParent(), MemoryContextSetParent(), NIL, CachedPlanSource::num_custom_plans, CachedPlanSource::num_generic_plans, plan, ReleaseGenericPlan(), ResourceOwnerEnlarge(), ResourceOwnerRememberPlanCacheRef(), RevalidateCachedQuery(), and CachedPlanSource::total_custom_cost.

Referenced by _SPI_execute_plan(), exec_bind_message(), ExecuteQuery(), ExplainExecuteQuery(), SPI_cursor_open_internal(), and SPI_plan_get_cached_plan().

◆ InitPlanCache()

void InitPlanCache ( void )

Definition at line 156 of file plancache.c.

{
    CacheRegisterRelcacheCallback(PlanCacheRelCallback, (Datum) 0);
    CacheRegisterSyscacheCallback(PROCOID, PlanCacheObjectCallback, (Datum) 0);
    CacheRegisterSyscacheCallback(TYPEOID, PlanCacheObjectCallback, (Datum) 0);
    CacheRegisterSyscacheCallback(NAMESPACEOID, PlanCacheSysCallback, (Datum) 0);
    CacheRegisterSyscacheCallback(OPEROID, PlanCacheSysCallback, (Datum) 0);
    CacheRegisterSyscacheCallback(AMOPOPID, PlanCacheSysCallback, (Datum) 0);
    CacheRegisterSyscacheCallback(FOREIGNSERVEROID, PlanCacheSysCallback, (Datum) 0);
    CacheRegisterSyscacheCallback(FOREIGNDATAWRAPPEROID, PlanCacheSysCallback, (Datum) 0);
}

References CacheRegisterRelcacheCallback(), CacheRegisterSyscacheCallback(), PlanCacheObjectCallback(), PlanCacheRelCallback(), and PlanCacheSysCallback().

Referenced by InitPostgres().

◆ PlanCacheComputeResultDesc()

static TupleDesc PlanCacheComputeResultDesc ( List * stmt_list )

static

Definition at line 2094 of file plancache.c.

{
    Query      *query;
 
    switch (ChoosePortalStrategy(stmt_list))
    {
        case PORTAL_ONE_SELECT:
        case PORTAL_ONE_MOD_WITH:
            query = linitial_node(Query, stmt_list);
            return ExecCleanTypeFromTL(query->targetList);
 
        case PORTAL_ONE_RETURNING:
            query = QueryListGetPrimaryStmt(stmt_list);
            Assert(query->returningList);
            return ExecCleanTypeFromTL(query->returningList);
 
        case PORTAL_UTIL_SELECT:
            query = linitial_node(Query, stmt_list);
            Assert(query->utilityStmt);
            return UtilityTupleDescriptor(query->utilityStmt);
 
        case PORTAL_MULTI_QUERY:
            /* will not return tuples */
            break;
    }
    return NULL;
}

References Assert(), ChoosePortalStrategy(), ExecCleanTypeFromTL(), linitial_node, PORTAL_MULTI_QUERY, PORTAL_ONE_MOD_WITH, PORTAL_ONE_RETURNING, PORTAL_ONE_SELECT, PORTAL_UTIL_SELECT, QueryListGetPrimaryStmt(), Query::returningList, Query::targetList, Query::utilityStmt, and UtilityTupleDescriptor().

Referenced by CompleteCachedPlan(), and RevalidateCachedQuery().

◆ PlanCacheObjectCallback()

static void PlanCacheObjectCallback	(	Datum	arg,
		int	cacheid,
		uint32	hashvalue
	)

static

Definition at line 2214 of file plancache.c.

{
    dlist_iter  iter;
 
    dlist_foreach(iter, &saved_plan_list)
    {
        CachedPlanSource *plansource = dlist_container(CachedPlanSource,
                                                       node, iter.cur);
        ListCell   *lc;
 
        Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
 
        /* No work if it's already invalidated */
        if (!plansource->is_valid)
            continue;
 
        /* Never invalidate if parse/plan would be a no-op anyway */
        if (!StmtPlanRequiresRevalidation(plansource))
            continue;
 
        /*
         * Check the dependency list for the rewritten querytree.
         */
        foreach(lc, plansource->invalItems)
        {
            PlanInvalItem *item = (PlanInvalItem *) lfirst(lc);
 
            if (item->cacheId != cacheid)
                continue;
            if (hashvalue == 0 ||
                item->hashValue == hashvalue)
            {
                /* Invalidate the querytree and generic plan */
                plansource->is_valid = false;
                if (plansource->gplan)
                    plansource->gplan->is_valid = false;
                break;
            }
        }
 
        /*
         * The generic plan, if any, could have more dependencies than the
         * querytree does, so we have to check it too.
         */
        if (plansource->gplan && plansource->gplan->is_valid)
        {
            foreach(lc, plansource->gplan->stmt_list)
            {
                PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
                ListCell   *lc3;
 
                if (plannedstmt->commandType == CMD_UTILITY)
                    continue;   /* Ignore utility statements */
                foreach(lc3, plannedstmt->invalItems)
                {
                    PlanInvalItem *item = (PlanInvalItem *) lfirst(lc3);
 
                    if (item->cacheId != cacheid)
                        continue;
                    if (hashvalue == 0 ||
                        item->hashValue == hashvalue)
                    {
                        /* Invalidate the generic plan only */
                        plansource->gplan->is_valid = false;
                        break;  /* out of invalItems scan */
                    }
                }
                if (!plansource->gplan->is_valid)
                    break;      /* out of stmt_list scan */
            }
        }
    }
 
    /* Likewise check cached expressions */
    dlist_foreach(iter, &cached_expression_list)
    {
        CachedExpression *cexpr = dlist_container(CachedExpression,
                                                  node, iter.cur);
        ListCell   *lc;
 
        Assert(cexpr->magic == CACHEDEXPR_MAGIC);
 
        /* No work if it's already invalidated */
        if (!cexpr->is_valid)
            continue;
 
        foreach(lc, cexpr->invalItems)
        {
            PlanInvalItem *item = (PlanInvalItem *) lfirst(lc);
 
            if (item->cacheId != cacheid)
                continue;
            if (hashvalue == 0 ||
                item->hashValue == hashvalue)
            {
                cexpr->is_valid = false;
                break;
            }
        }
    }
}

References Assert(), cached_expression_list, CACHEDEXPR_MAGIC, CACHEDPLANSOURCE_MAGIC, PlanInvalItem::cacheId, CMD_UTILITY, PlannedStmt::commandType, dlist_iter::cur, dlist_container, dlist_foreach, CachedPlanSource::gplan, PlanInvalItem::hashValue, PlannedStmt::invalItems, CachedPlanSource::invalItems, CachedExpression::invalItems, CachedPlanSource::is_valid, CachedPlan::is_valid, CachedExpression::is_valid, lfirst, lfirst_node, CachedPlanSource::magic, CachedExpression::magic, saved_plan_list, CachedPlan::stmt_list, and StmtPlanRequiresRevalidation.

Referenced by InitPlanCache().

◆ PlanCacheRelCallback()

static void PlanCacheRelCallback	(	Datum	arg,
		Oid	relid
	)

static

Definition at line 2130 of file plancache.c.

{
    dlist_iter  iter;
 
    dlist_foreach(iter, &saved_plan_list)
    {
        CachedPlanSource *plansource = dlist_container(CachedPlanSource,
                                                       node, iter.cur);
 
        Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
 
        /* No work if it's already invalidated */
        if (!plansource->is_valid)
            continue;
 
        /* Never invalidate if parse/plan would be a no-op anyway */
        if (!StmtPlanRequiresRevalidation(plansource))
            continue;
 
        /*
         * Check the dependency list for the rewritten querytree.
         */
        if ((relid == InvalidOid) ? plansource->relationOids != NIL :
            list_member_oid(plansource->relationOids, relid))
        {
            /* Invalidate the querytree and generic plan */
            plansource->is_valid = false;
            if (plansource->gplan)
                plansource->gplan->is_valid = false;
        }
 
        /*
         * The generic plan, if any, could have more dependencies than the
         * querytree does, so we have to check it too.
         */
        if (plansource->gplan && plansource->gplan->is_valid)
        {
            ListCell   *lc;
 
            foreach(lc, plansource->gplan->stmt_list)
            {
                PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
 
                if (plannedstmt->commandType == CMD_UTILITY)
                    continue;   /* Ignore utility statements */
                if ((relid == InvalidOid) ? plannedstmt->relationOids != NIL :
                    list_member_oid(plannedstmt->relationOids, relid))
                {
                    /* Invalidate the generic plan only */
                    plansource->gplan->is_valid = false;
                    break;      /* out of stmt_list scan */
                }
            }
        }
    }
 
    /* Likewise check cached expressions */
    dlist_foreach(iter, &cached_expression_list)
    {
        CachedExpression *cexpr = dlist_container(CachedExpression,
                                                  node, iter.cur);
 
        Assert(cexpr->magic == CACHEDEXPR_MAGIC);
 
        /* No work if it's already invalidated */
        if (!cexpr->is_valid)
            continue;
 
        if ((relid == InvalidOid) ? cexpr->relationOids != NIL :
            list_member_oid(cexpr->relationOids, relid))
        {
            cexpr->is_valid = false;
        }
    }
}

References Assert(), cached_expression_list, CACHEDEXPR_MAGIC, CACHEDPLANSOURCE_MAGIC, CMD_UTILITY, PlannedStmt::commandType, dlist_iter::cur, dlist_container, dlist_foreach, CachedPlanSource::gplan, InvalidOid, CachedPlanSource::is_valid, CachedPlan::is_valid, CachedExpression::is_valid, lfirst_node, list_member_oid(), CachedPlanSource::magic, CachedExpression::magic, NIL, PlannedStmt::relationOids, CachedPlanSource::relationOids, CachedExpression::relationOids, saved_plan_list, CachedPlan::stmt_list, and StmtPlanRequiresRevalidation.

Referenced by InitPlanCache().

◆ PlanCacheSysCallback()

static void PlanCacheSysCallback	(	Datum	arg,
		int	cacheid,
		uint32	hashvalue
	)

static

Definition at line 2323 of file plancache.c.

{
    ResetPlanCache();
}

References ResetPlanCache().

Referenced by InitPlanCache().

◆ QueryListGetPrimaryStmt()

static Query * QueryListGetPrimaryStmt ( List * stmts )

static

Definition at line 1897 of file plancache.c.

{
    ListCell   *lc;
 
    foreach(lc, stmts)
    {
        Query      *stmt = lfirst_node(Query, lc);
 
        if (stmt->canSetTag)
            return stmt;
    }
    return NULL;
}

References lfirst_node, and stmt.

Referenced by CachedPlanGetTargetList(), and PlanCacheComputeResultDesc().

◆ ReleaseAllPlanCacheRefsInOwner()

void ReleaseAllPlanCacheRefsInOwner ( ResourceOwner owner )

Definition at line 2379 of file plancache.c.

{
    ResourceOwnerReleaseAllOfKind(owner, &planref_resowner_desc);
}

References planref_resowner_desc, and ResourceOwnerReleaseAllOfKind().

Referenced by plpgsql_call_handler(), plpgsql_inline_handler(), and plpgsql_xact_cb().

◆ ReleaseCachedPlan()

void ReleaseCachedPlan	(	CachedPlan *	plan,
		ResourceOwner	owner
	)

Definition at line 1435 of file plancache.c.

{
    Assert(plan->magic == CACHEDPLAN_MAGIC);
    if (owner)
    {
        Assert(plan->is_saved);
        ResourceOwnerForgetPlanCacheRef(owner, plan);
    }
    Assert(plan->refcount > 0);
    plan->refcount--;
    if (plan->refcount == 0)
    {
        /* Mark it no longer valid */
        plan->magic = 0;
 
        /* One-shot plans do not own their context, so we can't free them */
        if (!plan->is_oneshot)
            MemoryContextDelete(plan->context);
    }
}

References Assert(), CACHEDPLAN_MAGIC, MemoryContextDelete(), plan, and ResourceOwnerForgetPlanCacheRef().

Referenced by _SPI_execute_plan(), exec_eval_simple_expr(), exec_simple_check_plan(), ExplainExecuteQuery(), make_callstmt_target(), PortalReleaseCachedPlan(), ReleaseGenericPlan(), ResOwnerReleaseCachedPlan(), and SPI_cursor_open_internal().

◆ ReleaseGenericPlan()

static void ReleaseGenericPlan ( CachedPlanSource * plansource )

static

Definition at line 556 of file plancache.c.

{
    /* Be paranoid about the possibility that ReleaseCachedPlan fails */
    if (plansource->gplan)
    {
        CachedPlan *plan = plansource->gplan;
 
        Assert(plan->magic == CACHEDPLAN_MAGIC);
        plansource->gplan = NULL;
        ReleaseCachedPlan(plan, NULL);
    }
}

References Assert(), CACHEDPLAN_MAGIC, CachedPlanSource::gplan, plan, and ReleaseCachedPlan().

Referenced by CheckCachedPlan(), DropCachedPlan(), GetCachedPlan(), RevalidateCachedQuery(), and SaveCachedPlan().

◆ ResetPlanCache()

void ResetPlanCache ( void )

Definition at line 2332 of file plancache.c.

{
    dlist_iter  iter;
 
    dlist_foreach(iter, &saved_plan_list)
    {
        CachedPlanSource *plansource = dlist_container(CachedPlanSource,
                                                       node, iter.cur);
 
        Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
 
        /* No work if it's already invalidated */
        if (!plansource->is_valid)
            continue;
 
        /*
         * We *must not* mark transaction control statements as invalid,
         * particularly not ROLLBACK, because they may need to be executed in
         * aborted transactions when we can't revalidate them (cf bug #5269).
         * In general there's no point in invalidating statements for which a
         * new parse analysis/rewrite/plan cycle would certainly give the same
         * results.
         */
        if (!StmtPlanRequiresRevalidation(plansource))
            continue;
 
        plansource->is_valid = false;
        if (plansource->gplan)
            plansource->gplan->is_valid = false;
    }
 
    /* Likewise invalidate cached expressions */
    dlist_foreach(iter, &cached_expression_list)
    {
        CachedExpression *cexpr = dlist_container(CachedExpression,
                                                  node, iter.cur);
 
        Assert(cexpr->magic == CACHEDEXPR_MAGIC);
 
        cexpr->is_valid = false;
    }
}

References Assert(), cached_expression_list, CACHEDEXPR_MAGIC, CACHEDPLANSOURCE_MAGIC, dlist_iter::cur, dlist_container, dlist_foreach, CachedPlanSource::gplan, CachedPlanSource::is_valid, CachedPlan::is_valid, CachedExpression::is_valid, CachedPlanSource::magic, CachedExpression::magic, saved_plan_list, and StmtPlanRequiresRevalidation.

Referenced by assign_session_replication_role(), DiscardAll(), DiscardCommand(), and PlanCacheSysCallback().

◆ ResourceOwnerForgetPlanCacheRef()

static void ResourceOwnerForgetPlanCacheRef	(	ResourceOwner	owner,
		CachedPlan *	plan
	)

inlinestatic

Definition at line 141 of file plancache.c.

{
    ResourceOwnerForget(owner, PointerGetDatum(plan), &planref_resowner_desc);
}

References plan, planref_resowner_desc, PointerGetDatum(), and ResourceOwnerForget().

Referenced by ReleaseCachedPlan().

◆ ResourceOwnerRememberPlanCacheRef()

static void ResourceOwnerRememberPlanCacheRef	(	ResourceOwner	owner,
		CachedPlan *	plan
	)

inlinestatic

Definition at line 136 of file plancache.c.

{
    ResourceOwnerRemember(owner, PointerGetDatum(plan), &planref_resowner_desc);
}

References plan, planref_resowner_desc, PointerGetDatum(), and ResourceOwnerRemember().

Referenced by CachedPlanAllowsSimpleValidityCheck(), CachedPlanIsSimplyValid(), and GetCachedPlan().

◆ ResOwnerReleaseCachedPlan()

static void ResOwnerReleaseCachedPlan ( Datum res )

static

Definition at line 2387 of file plancache.c.

{
    ReleaseCachedPlan((CachedPlan *) DatumGetPointer(res), NULL);
}

References DatumGetPointer(), and ReleaseCachedPlan().

◆ RevalidateCachedQuery()

static List * RevalidateCachedQuery	(	CachedPlanSource *	plansource,
		QueryEnvironment *	queryEnv,
		bool	release_generic
	)

static

Definition at line 590 of file plancache.c.

{
    bool        snapshot_set;
    RawStmt    *rawtree;
    List       *tlist;          /* transient query-tree list */
    List       *qlist;          /* permanent query-tree list */
    TupleDesc   resultDesc;
    MemoryContext querytree_context;
    MemoryContext oldcxt;
 
    /*
     * For one-shot plans, we do not support revalidation checking; it's
     * assumed the query is parsed, planned, and executed in one transaction,
     * so that no lock re-acquisition is necessary.  Also, if the statement
     * type can't require revalidation, we needn't do anything (and we mustn't
     * risk catalog accesses when handling, eg, transaction control commands).
     */
    if (plansource->is_oneshot || !StmtPlanRequiresRevalidation(plansource))
    {
        Assert(plansource->is_valid);
        return NIL;
    }
 
    /*
     * If the query is currently valid, we should have a saved search_path ---
     * check to see if that matches the current environment.  If not, we want
     * to force replan.
     */
    if (plansource->is_valid)
    {
        Assert(plansource->search_path != NULL);
        if (!SearchPathMatchesCurrentEnvironment(plansource->search_path))
        {
            /* Invalidate the querytree and generic plan */
            plansource->is_valid = false;
            if (plansource->gplan)
                plansource->gplan->is_valid = false;
        }
    }
 
    /*
     * If the query rewrite phase had a possible RLS dependency, we must redo
     * it if either the role or the row_security setting has changed.
     */
    if (plansource->is_valid && plansource->dependsOnRLS &&
        (plansource->rewriteRoleId != GetUserId() ||
         plansource->rewriteRowSecurity != row_security))
        plansource->is_valid = false;
 
    /*
     * If the query is currently valid, acquire locks on the referenced
     * objects; then check again.  We need to do it this way to cover the race
     * condition that an invalidation message arrives before we get the locks.
     */
    if (plansource->is_valid)
    {
        AcquirePlannerLocks(plansource->query_list, true);
 
        /*
         * By now, if any invalidation has happened, the inval callback
         * functions will have marked the query invalid.
         */
        if (plansource->is_valid)
        {
            /* Successfully revalidated and locked the query. */
            return NIL;
        }
 
        /* Oops, the race case happened.  Release useless locks. */
        AcquirePlannerLocks(plansource->query_list, false);
    }
 
    /*
     * Discard the no-longer-useful query tree.  (Note: we don't want to do
     * this any earlier, else we'd not have been able to release locks
     * correctly in the race condition case.)
     */
    plansource->is_valid = false;
    plansource->query_list = NIL;
    plansource->relationOids = NIL;
    plansource->invalItems = NIL;
    plansource->search_path = NULL;
 
    /*
     * Free the query_context.  We don't really expect MemoryContextDelete to
     * fail, but just in case, make sure the CachedPlanSource is left in a
     * reasonably sane state.  (The generic plan won't get unlinked yet, but
     * that's acceptable.)
     */
    if (plansource->query_context)
    {
        MemoryContext qcxt = plansource->query_context;
 
        plansource->query_context = NULL;
        MemoryContextDelete(qcxt);
    }
 
    /* Drop the generic plan reference, if any, and if requested */
    if (release_generic)
        ReleaseGenericPlan(plansource);
 
    /*
     * Now re-do parse analysis and rewrite.  This not incidentally acquires
     * the locks we need to do planning safely.
     */
    Assert(plansource->is_complete);
 
    /*
     * If a snapshot is already set (the normal case), we can just use that
     * for parsing/planning.  But if it isn't, install one.  Note: no point in
     * checking whether parse analysis requires a snapshot; utility commands
     * don't have invalidatable plans, so we'd not get here for such a
     * command.
     */
    snapshot_set = false;
    if (!ActiveSnapshotSet())
    {
        PushActiveSnapshot(GetTransactionSnapshot());
        snapshot_set = true;
    }
 
    /*
     * Run parse analysis and rule rewriting.  The parser tends to scribble on
     * its input, so we must copy the raw parse tree to prevent corruption of
     * the cache.
     */
    rawtree = copyObject(plansource->raw_parse_tree);
    if (rawtree == NULL)
        tlist = NIL;
    else if (plansource->parserSetup != NULL)
        tlist = pg_analyze_and_rewrite_withcb(rawtree,
                                              plansource->query_string,
                                              plansource->parserSetup,
                                              plansource->parserSetupArg,
                                              queryEnv);
    else
        tlist = pg_analyze_and_rewrite_fixedparams(rawtree,
                                                   plansource->query_string,
                                                   plansource->param_types,
                                                   plansource->num_params,
                                                   queryEnv);
 
    /* Release snapshot if we got one */
    if (snapshot_set)
        PopActiveSnapshot();
 
    /*
     * Check or update the result tupdesc.
     *
     * We assume the parameter types didn't change from the first time, so no
     * need to update that.
     */
    resultDesc = PlanCacheComputeResultDesc(tlist);
    if (resultDesc == NULL && plansource->resultDesc == NULL)
    {
        /* OK, doesn't return tuples */
    }
    else if (resultDesc == NULL || plansource->resultDesc == NULL ||
             !equalRowTypes(resultDesc, plansource->resultDesc))
    {
        /* can we give a better error message? */
        if (plansource->fixed_result)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cached plan must not change result type")));
        oldcxt = MemoryContextSwitchTo(plansource->context);
        if (resultDesc)
            resultDesc = CreateTupleDescCopy(resultDesc);
        if (plansource->resultDesc)
            FreeTupleDesc(plansource->resultDesc);
        plansource->resultDesc = resultDesc;
        MemoryContextSwitchTo(oldcxt);
    }
 
    /*
     * Allocate new query_context and copy the completed querytree into it.
     * It's transient until we complete the copying and dependency extraction.
     */
    querytree_context = AllocSetContextCreate(CurrentMemoryContext,
                                              "CachedPlanQuery",
                                              ALLOCSET_START_SMALL_SIZES);
    oldcxt = MemoryContextSwitchTo(querytree_context);
 
    qlist = copyObject(tlist);
 
    /*
     * Use the planner machinery to extract dependencies.  Data is saved in
     * query_context.  (We assume that not a lot of extra cruft is created by
     * this call.)
     */
    extract_query_dependencies((Node *) qlist,
                               &plansource->relationOids,
                               &plansource->invalItems,
                               &plansource->dependsOnRLS);
 
    /* Update RLS info as well. */
    plansource->rewriteRoleId = GetUserId();
    plansource->rewriteRowSecurity = row_security;
 
    /*
     * Also save the current search_path in the query_context.  (This should
     * not generate much extra cruft either, since almost certainly the path
     * is already valid.)
     */
    plansource->search_path = GetSearchPathMatcher(querytree_context);
 
    MemoryContextSwitchTo(oldcxt);
 
    /* Now reparent the finished query_context and save the links */
    MemoryContextSetParent(querytree_context, plansource->context);
 
    plansource->query_context = querytree_context;
    plansource->query_list = qlist;
 
    /*
     * Note: we do not reset generic_cost or total_custom_cost, although we
     * could choose to do so.  If the DDL or statistics change that prompted
     * the invalidation meant a significant change in the cost estimates, it
     * would be better to reset those variables and start fresh; but often it
     * doesn't, and we're better retaining our hard-won knowledge about the
     * relative costs.
     */
 
    plansource->is_valid = true;
 
    /* Return transient copy of querytrees for possible use in planning */
    return tlist;
}

References AcquirePlannerLocks(), ActiveSnapshotSet(), ALLOCSET_START_SMALL_SIZES, AllocSetContextCreate, Assert(), CachedPlanSource::context, copyObject, CreateTupleDescCopy(), CurrentMemoryContext, CachedPlanSource::dependsOnRLS, equalRowTypes(), ereport, errcode(), errmsg(), ERROR, extract_query_dependencies(), CachedPlanSource::fixed_result, FreeTupleDesc(), GetSearchPathMatcher(), GetTransactionSnapshot(), GetUserId(), CachedPlanSource::gplan, CachedPlanSource::invalItems, CachedPlanSource::is_complete, CachedPlanSource::is_oneshot, CachedPlanSource::is_valid, CachedPlan::is_valid, MemoryContextDelete(), MemoryContextSetParent(), MemoryContextSwitchTo(), NIL, CachedPlanSource::num_params, CachedPlanSource::param_types, CachedPlanSource::parserSetup, CachedPlanSource::parserSetupArg, pg_analyze_and_rewrite_fixedparams(), pg_analyze_and_rewrite_withcb(), PlanCacheComputeResultDesc(), PopActiveSnapshot(), PushActiveSnapshot(), CachedPlanSource::query_context, CachedPlanSource::query_list, CachedPlanSource::query_string, CachedPlanSource::raw_parse_tree, CachedPlanSource::relationOids, ReleaseGenericPlan(), CachedPlanSource::resultDesc, CachedPlanSource::rewriteRoleId, CachedPlanSource::rewriteRowSecurity, row_security, CachedPlanSource::search_path, SearchPathMatchesCurrentEnvironment(), and StmtPlanRequiresRevalidation.

Referenced by BuildCachedPlan(), CachedPlanGetTargetList(), GetCachedPlan(), and UpdateCachedPlan().

◆ SaveCachedPlan()

void SaveCachedPlan ( CachedPlanSource * plansource )

Definition at line 483 of file plancache.c.

{
    /* Assert caller is doing things in a sane order */
    Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
    Assert(plansource->is_complete);
    Assert(!plansource->is_saved);
 
    /* This seems worth a real test, though */
    if (plansource->is_oneshot)
        elog(ERROR, "cannot save one-shot cached plan");
 
    /*
     * In typical use, this function would be called before generating any
     * plans from the CachedPlanSource.  If there is a generic plan, moving it
     * into CacheMemoryContext would be pretty risky since it's unclear
     * whether the caller has taken suitable care with making references
     * long-lived.  Best thing to do seems to be to discard the plan.
     */
    ReleaseGenericPlan(plansource);
 
    /*
     * Reparent the source memory context under CacheMemoryContext so that it
     * will live indefinitely.  The query_context follows along since it's
     * already a child of the other one.
     */
    MemoryContextSetParent(plansource->context, CacheMemoryContext);
 
    /*
     * Add the entry to the global list of cached plans.
     */
    dlist_push_tail(&saved_plan_list, &plansource->node);
 
    plansource->is_saved = true;
}

References Assert(), CACHEDPLANSOURCE_MAGIC, CacheMemoryContext, CachedPlanSource::context, dlist_push_tail(), elog, ERROR, CachedPlanSource::is_complete, CachedPlanSource::is_oneshot, CachedPlanSource::is_saved, CachedPlanSource::magic, MemoryContextSetParent(), CachedPlanSource::node, ReleaseGenericPlan(), and saved_plan_list.

Referenced by _SPI_save_plan(), exec_parse_message(), SPI_keepplan(), and StorePreparedStatement().

◆ ScanQueryForLocks()

static void ScanQueryForLocks	(	Query *	parsetree,
		bool	acquire
	)

static

Definition at line 2000 of file plancache.c.

{
    ListCell   *lc;
 
    /* Shouldn't get called on utility commands */
    Assert(parsetree->commandType != CMD_UTILITY);
 
    /*
     * First, process RTEs of the current query level.
     */
    foreach(lc, parsetree->rtable)
    {
        RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
 
        switch (rte->rtekind)
        {
            case RTE_RELATION:
                /* Acquire or release the appropriate type of lock */
                if (acquire)
                    LockRelationOid(rte->relid, rte->rellockmode);
                else
                    UnlockRelationOid(rte->relid, rte->rellockmode);
                break;
 
            case RTE_SUBQUERY:
                /* If this was a view, must lock/unlock the view */
                if (OidIsValid(rte->relid))
                {
                    if (acquire)
                        LockRelationOid(rte->relid, rte->rellockmode);
                    else
                        UnlockRelationOid(rte->relid, rte->rellockmode);
                }
                /* Recurse into subquery-in-FROM */
                ScanQueryForLocks(rte->subquery, acquire);
                break;
 
            default:
                /* ignore other types of RTEs */
                break;
        }
    }
 
    /* Recurse into subquery-in-WITH */
    foreach(lc, parsetree->cteList)
    {
        CommonTableExpr *cte = lfirst_node(CommonTableExpr, lc);
 
        ScanQueryForLocks(castNode(Query, cte->ctequery), acquire);
    }
 
    /*
     * Recurse into sublink subqueries, too.  But we already did the ones in
     * the rtable and cteList.
     */
    if (parsetree->hasSubLinks)
    {
        query_tree_walker(parsetree, ScanQueryWalker, &acquire,
                          QTW_IGNORE_RC_SUBQUERIES);
    }
}

References Assert(), castNode, CMD_UTILITY, Query::commandType, Query::cteList, CommonTableExpr::ctequery, lfirst, lfirst_node, LockRelationOid(), OidIsValid, QTW_IGNORE_RC_SUBQUERIES, query_tree_walker, RangeTblEntry::relid, Query::rtable, RTE_RELATION, RTE_SUBQUERY, RangeTblEntry::rtekind, ScanQueryForLocks(), ScanQueryWalker(), RangeTblEntry::subquery, and UnlockRelationOid().

Referenced by AcquireExecutorLocks(), AcquirePlannerLocks(), ScanQueryForLocks(), and ScanQueryWalker().

◆ ScanQueryWalker()

static bool ScanQueryWalker	(	Node *	node,
		bool *	acquire
	)

static

Definition at line 2066 of file plancache.c.

{
    if (node == NULL)
        return false;
    if (IsA(node, SubLink))
    {
        SubLink    *sub = (SubLink *) node;
 
        /* Do what we came for */
        ScanQueryForLocks(castNode(Query, sub->subselect), *acquire);
        /* Fall through to process lefthand args of SubLink */
    }
 
    /*
     * Do NOT recurse into Query nodes, because ScanQueryForLocks already
     * processed subselects of subselects for us.
     */
    return expression_tree_walker(node, ScanQueryWalker, acquire);
}

References castNode, expression_tree_walker, IsA, ScanQueryForLocks(), ScanQueryWalker(), and SubLink::subselect.

Referenced by ScanQueryForLocks(), and ScanQueryWalker().

◆ UpdateCachedPlan()

PlannedStmt * UpdateCachedPlan	(	CachedPlanSource *	plansource,
		int	query_index,
		QueryEnvironment *	queryEnv
	)

Definition at line 1093 of file plancache.c.

{
    List       *query_list = plansource->query_list,
               *plan_list;
    ListCell   *l1,
               *l2;
    CachedPlan *plan = plansource->gplan;
    MemoryContext oldcxt;
 
    Assert(ActiveSnapshotSet());
 
    /* Sanity checks (XXX can be Asserts?) */
    if (plan == NULL)
        elog(ERROR, "UpdateCachedPlan() called in the wrong context: plansource->gplan is NULL");
    else if (plan->is_valid)
        elog(ERROR, "UpdateCachedPlan() called in the wrong context: plansource->gplan->is_valid is true");
    else if (plan->is_oneshot)
        elog(ERROR, "UpdateCachedPlan() called in the wrong context: plansource->gplan->is_oneshot is true");
 
    /*
     * The plansource might have become invalid since GetCachedPlan() returned
     * the CachedPlan. See the comment in BuildCachedPlan() for details on why
     * this might happen.  Although invalidation is likely a false positive as
     * stated there, we make the plan valid to ensure the query list used for
     * planning is up to date.
     *
     * The risk of catching an invalidation is higher here than when
     * BuildCachedPlan() is called from GetCachedPlan(), because this function
     * is normally called long after GetCachedPlan() returns the CachedPlan,
     * so much more processing could have occurred including things that mark
     * the CachedPlanSource invalid.
     *
     * Note: Do not release plansource->gplan, because the upstream callers
     * (such as the callers of ExecutorStartCachedPlan()) would still be
     * referencing it.
     */
    if (!plansource->is_valid)
        query_list = RevalidateCachedQuery(plansource, queryEnv, false);
    Assert(query_list != NIL);
 
    /*
     * Build a new generic plan for all the queries after making a copy to be
     * scribbled on by the planner.
     */
    query_list = copyObject(query_list);
 
    /*
     * Planning work is done in the caller's memory context.  The resulting
     * PlannedStmt is then copied into plan->stmt_context after throwing away
     * the old ones.
     */
    plan_list = pg_plan_queries(query_list, plansource->query_string,
                                plansource->cursor_options, NULL);
    Assert(list_length(plan_list) == list_length(plan->stmt_list));
 
    MemoryContextReset(plan->stmt_context);
    oldcxt = MemoryContextSwitchTo(plan->stmt_context);
    forboth(l1, plan_list, l2, plan->stmt_list)
    {
        PlannedStmt *plannedstmt = lfirst(l1);
 
        lfirst(l2) = copyObject(plannedstmt);
    }
    MemoryContextSwitchTo(oldcxt);
 
    /*
     * XXX Should this also (re)set the properties of the CachedPlan that are
     * set in BuildCachedPlan() after creating the fresh plans such as
     * planRoleId, dependsOnRole, and save_xmin?
     */
 
    /*
     * We've updated all the plans that might have been invalidated, so mark
     * the CachedPlan as valid.
     */
    plan->is_valid = true;
 
    /* Also update generic_cost because we just created a new generic plan. */
    plansource->generic_cost = cached_plan_cost(plan, false);
 
    return list_nth_node(PlannedStmt, plan->stmt_list, query_index);
}

References ActiveSnapshotSet(), Assert(), cached_plan_cost(), copyObject, CachedPlanSource::cursor_options, elog, ERROR, forboth, CachedPlanSource::generic_cost, CachedPlanSource::gplan, CachedPlanSource::is_valid, lfirst, list_length(), list_nth_node, MemoryContextReset(), MemoryContextSwitchTo(), NIL, pg_plan_queries(), plan, CachedPlanSource::query_list, CachedPlanSource::query_string, and RevalidateCachedQuery().

Referenced by ExecutorStartCachedPlan().

Variable Documentation

◆ cached_expression_list

dlist_head cached_expression_list = DLIST_STATIC_INIT(cached_expression_list)

static

Definition at line 100 of file plancache.c.

Referenced by GetCachedExpression(), PlanCacheObjectCallback(), PlanCacheRelCallback(), and ResetPlanCache().

◆ plan_cache_mode

int plan_cache_mode = PLAN_CACHE_MODE_AUTO

Definition at line 148 of file plancache.c.

Referenced by choose_custom_plan().

◆ planref_resowner_desc

const ResourceOwnerDesc planref_resowner_desc

static

Initial value:

=
{
    .name = "plancache reference",
    .release_phase = RESOURCE_RELEASE_AFTER_LOCKS,
    .release_priority = RELEASE_PRIO_PLANCACHE_REFS,
    .ReleaseResource = ResOwnerReleaseCachedPlan,
    .DebugPrint = NULL          
}

Definition at line 125 of file plancache.c.

Referenced by ReleaseAllPlanCacheRefsInOwner(), ResourceOwnerForgetPlanCacheRef(), and ResourceOwnerRememberPlanCacheRef().

◆ saved_plan_list

dlist_head saved_plan_list = DLIST_STATIC_INIT(saved_plan_list)

static

Definition at line 95 of file plancache.c.

Referenced by PlanCacheObjectCallback(), PlanCacheRelCallback(), ResetPlanCache(), and SaveCachedPlan().

Macros

Functions

Variables

Macro Definition Documentation

◆ StmtPlanRequiresRevalidation

Function Documentation

◆ AcquireExecutorLocks()

◆ AcquirePlannerLocks()

◆ BuildCachedPlan()

◆ cached_plan_cost()

◆ CachedPlanAllowsSimpleValidityCheck()

◆ CachedPlanGetTargetList()

◆ CachedPlanIsSimplyValid()

◆ CachedPlanIsValid()

◆ CachedPlanSetParentContext()

◆ CheckCachedPlan()

◆ choose_custom_plan()

◆ CompleteCachedPlan()

◆ CopyCachedPlan()

◆ CreateCachedPlan()

◆ CreateOneShotCachedPlan()

◆ DropCachedPlan()

◆ FreeCachedExpression()

◆ GetCachedExpression()

◆ GetCachedPlan()

◆ InitPlanCache()

◆ PlanCacheComputeResultDesc()

◆ PlanCacheObjectCallback()

◆ PlanCacheRelCallback()

◆ PlanCacheSysCallback()

◆ QueryListGetPrimaryStmt()

◆ ReleaseAllPlanCacheRefsInOwner()

◆ ReleaseCachedPlan()

◆ ReleaseGenericPlan()

◆ ResetPlanCache()

◆ ResourceOwnerForgetPlanCacheRef()

◆ ResourceOwnerRememberPlanCacheRef()

◆ ResOwnerReleaseCachedPlan()

◆ RevalidateCachedQuery()

◆ SaveCachedPlan()

◆ ScanQueryForLocks()

◆ ScanQueryWalker()

◆ UpdateCachedPlan()

Variable Documentation

◆ cached_expression_list

◆ plan_cache_mode

◆ planref_resowner_desc

◆ saved_plan_list