plancache.c File Reference

#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 "parser/parsetree.h"
#include "storage/lmgr.h"
#include "tcop/pquery.h"
#include "tcop/utility.h"
#include "utils/inval.h"
#include "utils/memutils.h"
#include "utils/resowner_private.h"
#include "utils/rls.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for plancache.c:

Go to the source code of this file.

Macros
#define	StmtPlanRequiresRevalidation(plansource)

Functions
static void	ReleaseGenericPlan (CachedPlanSource *plansource)
static List *	RevalidateCachedQuery (CachedPlanSource *plansource, QueryEnvironment *queryEnv)
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)
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)
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)

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)
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))

Definition at line 86 of file plancache.c.

Function Documentation

AcquireExecutorLocks()

static void AcquireExecutorLocks ( List *  stmt_list, bool  acquire  )

static

Definition at line 1749 of file plancache.c.

{
    ListCell   *lc1;
 
    foreach(lc1, stmt_list)
    {
        PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc1);
        ListCell   *lc2;
 
        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;
        }
 
        foreach(lc2, plannedstmt->rtable)
        {
            RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc2);
 
            if (!(rte->rtekind == RTE_RELATION ||
                  (rte->rtekind == RTE_SUBQUERY && OidIsValid(rte->relid))))
                continue;
 
            /*
             * 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 CMD_UTILITY, PlannedStmt::commandType, lfirst, lfirst_node, LockRelationOid(), OidIsValid, RangeTblEntry::relid, RangeTblEntry::rellockmode, PlannedStmt::rtable, RTE_RELATION, RTE_SUBQUERY, RangeTblEntry::rtekind, ScanQueryForLocks(), UnlockRelationOid(), UtilityContainsQuery(), and PlannedStmt::utilityStmt.

Referenced by CheckCachedPlan().

AcquirePlannerLocks()

static void AcquirePlannerLocks ( List *  stmt_list, bool  acquire  )

static

Definition at line 1805 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 883 of file plancache.c.

{
    CachedPlan *plan;
    List       *plist;
    bool        snapshot_set;
    bool        is_transient;
    MemoryContext plan_context;
    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);
 
    /*
     * 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 make a dedicated memory context for the CachedPlan and its
     * subsidiary data.  (It's probably not going to be large, but just in
     * case, allow it to grow large.  It's transient for the moment.)  But for
     * a one-shot plan, we just leave it in the caller's memory context.
     */
    if (!plansource->is_oneshot)
    {
        plan_context = AllocSetContextCreate(CurrentMemoryContext,
                                             "CachedPlan",
                                             ALLOCSET_START_SMALL_SIZES);
        MemoryContextCopyAndSetIdentifier(plan_context, plansource->query_string);
 
        /*
         * Copy plan into the new context.
         */
        MemoryContextSwitchTo(plan_context);
 
        plist = copyObject(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->is_oneshot = plansource->is_oneshot;
    plan->is_saved = 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, MemoryContextCopyAndSetIdentifier, 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 1080 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().

CachedPlanAllowsSimpleValidityCheck()

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

Definition at line 1313 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)
    {
        ResourceOwnerEnlargePlanCacheRefs(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, ResourceOwnerEnlargePlanCacheRefs(), 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 1617 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);
 
    /* 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 1428 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)
    {
        ResourceOwnerEnlargePlanCacheRefs(owner);
        plan->refcount++;
        ResourceOwnerRememberPlanCacheRef(owner, plan);
    }
 
    return true;
}

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

Referenced by exec_eval_simple_expr().

CachedPlanIsValid()

bool CachedPlanIsValid

(

CachedPlanSource *

plansource

)

Definition at line 1604 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 1475 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 799 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 1023 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 342 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;
}

References ALLOCSET_START_SMALL_SIZES, AllocSetContextCreate, Assert(), CACHEDPLANSOURCE_MAGIC, CachedPlanSource::context, copyObject, CurrentMemoryContext, CachedPlanSource::cursor_options, CachedPlanSource::dependsOnRLS, extract_query_dependencies(), CachedPlanSource::fixed_result, GetSearchPathMatcher(), GetUserId(), CachedPlanSource::invalItems, CachedPlanSource::is_complete, CachedPlanSource::is_oneshot, CachedPlanSource::is_valid, CachedPlanSource::magic, MemoryContextSetParent(), MemoryContextSwitchTo(), CachedPlanSource::num_params, palloc(), CachedPlanSource::param_types, CachedPlanSource::parserSetup, CachedPlanSource::parserSetupArg, PlanCacheComputeResultDesc(), CachedPlanSource::query_context, CachedPlanSource::query_list, CachedPlanSource::relationOids, CachedPlanSource::resultDesc, CachedPlanSource::rewriteRoleId, CachedPlanSource::rewriteRowSecurity, row_security, CachedPlanSource::search_path, and StmtPlanRequiresRevalidation.

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

CopyCachedPlan()

CachedPlanSource* CopyCachedPlan

(

CachedPlanSource *

plansource

)

Definition at line 1513 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;
}

References ALLOCSET_START_SMALL_SIZES, AllocSetContextCreate, Assert(), CACHEDPLANSOURCE_MAGIC, CachedPlanSource::commandTag, CachedPlanSource::context, copyObject, CopySearchPathMatcher(), CreateTupleDescCopy(), CurrentMemoryContext, CachedPlanSource::cursor_options, CachedPlanSource::dependsOnRLS, elog(), ERROR, CachedPlanSource::fixed_result, CachedPlanSource::generation, CachedPlanSource::generic_cost, CachedPlanSource::gplan, CachedPlanSource::invalItems, CachedPlanSource::is_complete, CachedPlanSource::is_oneshot, CachedPlanSource::is_saved, CachedPlanSource::is_valid, CachedPlanSource::magic, MemoryContextSetIdentifier(), MemoryContextSwitchTo(), CachedPlanSource::num_custom_plans, CachedPlanSource::num_generic_plans, CachedPlanSource::num_params, palloc(), palloc0(), CachedPlanSource::param_types, CachedPlanSource::parserSetup, CachedPlanSource::parserSetupArg, pstrdup(), CachedPlanSource::query_context, CachedPlanSource::query_list, CachedPlanSource::query_string, CachedPlanSource::raw_parse_tree, CachedPlanSource::relationOids, CachedPlanSource::resultDesc, CachedPlanSource::rewriteRoleId, CachedPlanSource::rewriteRowSecurity, CachedPlanSource::search_path, and CachedPlanSource::total_custom_cost.

Referenced by _SPI_save_plan().

CreateCachedPlan()

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

Definition at line 168 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;
}

References ALLOCSET_START_SMALL_SIZES, AllocSetContextCreate, Assert(), CACHEDPLANSOURCE_MAGIC, CachedPlanSource::commandTag, CachedPlanSource::context, copyObject, CurrentMemoryContext, CachedPlanSource::cursor_options, CachedPlanSource::dependsOnRLS, CachedPlanSource::fixed_result, CachedPlanSource::generation, CachedPlanSource::generic_cost, CachedPlanSource::gplan, InvalidOid, CachedPlanSource::invalItems, CachedPlanSource::is_complete, CachedPlanSource::is_oneshot, CachedPlanSource::is_saved, CachedPlanSource::is_valid, CachedPlanSource::magic, MemoryContextSetIdentifier(), MemoryContextSwitchTo(), NIL, CachedPlanSource::num_custom_plans, CachedPlanSource::num_generic_plans, CachedPlanSource::num_params, palloc0(), CachedPlanSource::param_types, CachedPlanSource::parserSetup, CachedPlanSource::parserSetupArg, pstrdup(), CachedPlanSource::query_context, CachedPlanSource::query_list, CachedPlanSource::query_string, CachedPlanSource::raw_parse_tree, CachedPlanSource::relationOids, CachedPlanSource::resultDesc, CachedPlanSource::rewriteRoleId, CachedPlanSource::rewriteRowSecurity, CachedPlanSource::search_path, and CachedPlanSource::total_custom_cost.

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

References Assert(), CACHEDPLANSOURCE_MAGIC, CachedPlanSource::commandTag, CachedPlanSource::context, CurrentMemoryContext, CachedPlanSource::cursor_options, CachedPlanSource::dependsOnRLS, CachedPlanSource::fixed_result, CachedPlanSource::generation, CachedPlanSource::generic_cost, CachedPlanSource::gplan, InvalidOid, CachedPlanSource::invalItems, CachedPlanSource::is_complete, CachedPlanSource::is_oneshot, CachedPlanSource::is_saved, CachedPlanSource::is_valid, CachedPlanSource::magic, NIL, CachedPlanSource::num_custom_plans, CachedPlanSource::num_generic_plans, CachedPlanSource::num_params, palloc0(), CachedPlanSource::param_types, CachedPlanSource::parserSetup, CachedPlanSource::parserSetupArg, CachedPlanSource::query_context, CachedPlanSource::query_list, CachedPlanSource::query_string, CachedPlanSource::raw_parse_tree, CachedPlanSource::relationOids, CachedPlanSource::resultDesc, CachedPlanSource::rewriteRoleId, CachedPlanSource::rewriteRowSecurity, CachedPlanSource::search_path, and CachedPlanSource::total_custom_cost.

Referenced by _SPI_prepare_oneshot_plan().

DropCachedPlan()

void DropCachedPlan

(

CachedPlanSource *

plansource

)

Definition at line 502 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 1711 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 1654 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 1145 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);
 
    /* 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);
        }
        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)
        ResourceOwnerEnlargePlanCacheRefs(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(), ResourceOwnerEnlargePlanCacheRefs(), 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 131 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 AMOPOPID, CacheRegisterRelcacheCallback(), CacheRegisterSyscacheCallback(), FOREIGNDATAWRAPPEROID, FOREIGNSERVEROID, NAMESPACEOID, OPEROID, PlanCacheObjectCallback(), PlanCacheRelCallback(), PlanCacheSysCallback(), PROCOID, and TYPEOID.

Referenced by InitPostgres().

PlanCacheComputeResultDesc()

static TupleDesc PlanCacheComputeResultDesc ( List *  stmt_list )

static

Definition at line 1926 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 2046 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 1962 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 2155 of file plancache.c.

{
    ResetPlanCache();
}

References ResetPlanCache().

Referenced by InitPlanCache().

QueryListGetPrimaryStmt()

static Query * QueryListGetPrimaryStmt ( List *  stmts )

static

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

ReleaseCachedPlan()

void ReleaseCachedPlan	(	CachedPlan *	plan,
		ResourceOwner	owner
	)

Definition at line 1268 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(), PortalReleaseCachedPlan(), ReleaseGenericPlan(), ResourceOwnerReleaseAllPlanCacheRefs(), ResourceOwnerReleaseInternal(), and SPI_cursor_open_internal().

ReleaseGenericPlan()

static void ReleaseGenericPlan ( CachedPlanSource *  plansource )

static

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

RevalidateCachedQuery()

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

static

Definition at line 559 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 */
    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.  XXX should we use a weaker
     * condition than equalTupleDescs() here?
     *
     * 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 ||
             !equalTupleDescs(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, equalTupleDescs(), 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(), and GetCachedPlan().

SaveCachedPlan()

void SaveCachedPlan

(

CachedPlanSource *

plansource

)

Definition at line 458 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 1830 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,
                          (void *) &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, RangeTblEntry::rellockmode, Query::rtable, RTE_RELATION, RTE_SUBQUERY, RangeTblEntry::rtekind, ScanQueryWalker(), RangeTblEntry::subquery, and UnlockRelationOid().

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

ScanQueryWalker()

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

static

Definition at line 1897 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,
                                  (void *) acquire);
}

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

Referenced by ScanQueryForLocks().

Variable Documentation

cached_expression_list

dlist_head cached_expression_list = DLIST_STATIC_INIT(cached_expression_list)

static

Definition at line 101 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 123 of file plancache.c.

Referenced by choose_custom_plan().

saved_plan_list

dlist_head saved_plan_list = DLIST_STATIC_INIT(saved_plan_list)

static

Definition at line 96 of file plancache.c.

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