plancache.h File Reference

#include "access/tupdesc.h"
#include "lib/ilist.h"
#include "nodes/params.h"
#include "tcop/cmdtag.h"
#include "utils/queryenvironment.h"
#include "utils/resowner.h"

Include dependency graph for plancache.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	CachedPlanSource
struct	CachedPlan
struct	CachedExpression

Macros
#define	CACHEDPLANSOURCE_MAGIC   195726186
#define	CACHEDPLAN_MAGIC   953717834
#define	CACHEDEXPR_MAGIC   838275847

Typedefs
typedef struct CachedPlanSource	CachedPlanSource
typedef struct CachedPlan	CachedPlan
typedef struct CachedExpression	CachedExpression

Enumerations
enum	PlanCacheMode { PLAN_CACHE_MODE_AUTO , PLAN_CACHE_MODE_FORCE_GENERIC_PLAN , PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN }

Functions
void	InitPlanCache (void)
void	ResetPlanCache (void)
void	ReleaseAllPlanCacheRefsInOwner (ResourceOwner owner)
CachedPlanSource *	CreateCachedPlan (struct RawStmt *raw_parse_tree, const char *query_string, CommandTag commandTag)
CachedPlanSource *	CreateOneShotCachedPlan (struct 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)
void	CachedPlanSetParentContext (CachedPlanSource *plansource, MemoryContext newcontext)
CachedPlanSource *	CopyCachedPlan (CachedPlanSource *plansource)
bool	CachedPlanIsValid (CachedPlanSource *plansource)
List *	CachedPlanGetTargetList (CachedPlanSource *plansource, 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)
CachedExpression *	GetCachedExpression (Node *expr)
void	FreeCachedExpression (CachedExpression *cexpr)

Variables
PGDLLIMPORT int	plan_cache_mode

Macro Definition Documentation

CACHEDEXPR_MAGIC

#define CACHEDEXPR_MAGIC   838275847

Definition at line 42 of file plancache.h.

CACHEDPLAN_MAGIC

#define CACHEDPLAN_MAGIC   953717834

Definition at line 41 of file plancache.h.

CACHEDPLANSOURCE_MAGIC

#define CACHEDPLANSOURCE_MAGIC   195726186

Definition at line 40 of file plancache.h.

Typedef Documentation

CachedExpression

typedef struct CachedExpression CachedExpression

CachedPlan

typedef struct CachedPlan CachedPlan

CachedPlanSource

typedef struct CachedPlanSource CachedPlanSource

Enumeration Type Documentation

PlanCacheMode

enum PlanCacheMode

Enumerator
PLAN_CACHE_MODE_AUTO
PLAN_CACHE_MODE_FORCE_GENERIC_PLAN
PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN

Definition at line 30 of file plancache.h.

{
    PLAN_CACHE_MODE_AUTO,
    PLAN_CACHE_MODE_FORCE_GENERIC_PLAN,
    PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN,
}           PlanCacheMode;

Function Documentation

CachedPlanAllowsSimpleValidityCheck()

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

Definition at line 1336 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 1640 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 1451 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 1627 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 1498 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().

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 366 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 1536 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	(	struct RawStmt *	raw_parse_tree,
		const char *	query_string,
		CommandTag	commandTag
	)

Definition at line 192 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	(	struct RawStmt *	raw_parse_tree,
		const char *	query_string,
		CommandTag	commandTag
	)

Definition at line 276 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 526 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 1734 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 1677 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 1168 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)
        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 155 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().

ReleaseAllPlanCacheRefsInOwner()

void ReleaseAllPlanCacheRefsInOwner

(

ResourceOwner

owner

)

Definition at line 2234 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 1291 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(), ResOwnerReleaseCachedPlan(), and SPI_cursor_open_internal().

ResetPlanCache()

void ResetPlanCache

(

void

)

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

SaveCachedPlan()

void SaveCachedPlan

(

CachedPlanSource *

plansource

)

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

Variable Documentation

plan_cache_mode

PGDLLIMPORT int plan_cache_mode

extern

Definition at line 147 of file plancache.c.

Referenced by choose_custom_plan().