00024 /*

00025  * CachedPlanSource (which might better have been called CachedQuery)

00026  * represents a SQL query that we expect to use multiple times.  It stores

00027  * the query source text, the raw parse tree, and the analyzed-and-rewritten

00028  * query tree, as well as adjunct data.  Cache invalidation can happen as a

00029  * result of DDL affecting objects used by the query.  In that case we discard

00030  * the analyzed-and-rewritten query tree, and rebuild it when next needed.

00031  *

00032  * An actual execution plan, represented by CachedPlan, is derived from the

00033  * CachedPlanSource when we need to execute the query.  The plan could be

00034  * either generic (usable with any set of plan parameters) or custom (for a

00035  * specific set of parameters).  plancache.c contains the logic that decides

00036  * which way to do it for any particular execution.  If we are using a generic

00037  * cached plan then it is meant to be re-used across multiple executions, so

00038  * callers must always treat CachedPlans as read-only.

00039  *

00040  * Once successfully built and "saved", CachedPlanSources typically live

00041  * for the life of the backend, although they can be dropped explicitly.

00042  * CachedPlans are reference-counted and go away automatically when the last

00043  * reference is dropped.  A CachedPlan can outlive the CachedPlanSource it

00044  * was created from.

00045  *

00046  * An "unsaved" CachedPlanSource can be used for generating plans, but it

00047  * lives in transient storage and will not be updated in response to sinval

00048  * events.

00049  *

00050  * CachedPlans made from saved CachedPlanSources are likewise in permanent

00051  * storage, so to avoid memory leaks, the reference-counted references to them

00052  * must be held in permanent data structures or ResourceOwners.  CachedPlans

00053  * made from unsaved CachedPlanSources are in children of the caller's

00054  * memory context, so references to them should not be longer-lived than

00055  * that context.  (Reference counting is somewhat pro forma in that case,

00056  * though it may be useful if the CachedPlan can be discarded early.)

00057  *

00058  * A CachedPlanSource has two associated memory contexts: one that holds the

00059  * struct itself, the query source text and the raw parse tree, and another

00060  * context that holds the rewritten query tree and associated data.  This

00061  * allows the query tree to be discarded easily when it is invalidated.

00062  *

00063  * Note: the string referenced by commandTag is not subsidiary storage;

00064  * it is assumed to be a compile-time-constant string.  As with portals,

00065  * commandTag shall be NULL if and only if the original query string (before

00066  * rewriting) was an empty string.

00067  */

00068 typedef struct CachedPlanSource

00069 {

00070     int         magic ;           /* should equal CACHEDPLANSOURCE_MAGIC */

00071     Node       * raw_parse_tree ; /* output of raw_parser() */

00072     char       * query_string ;   /* source text of query */

00073     const char * commandTag ;     /* command tag (a constant!), or NULL */

00074     Oid         * param_types ;     /* array of parameter type OIDs, or NULL */

00075     int         num_params ;     /* length of param_types array */

00076     ParserSetupHook parserSetup ;     /* alternative parameter spec method */

00077     void       * parserSetupArg ;

00078     int         cursor_options ; /* cursor options used for planning */

00079     bool        fixed_result ;   /* disallow change in result tupdesc? */

00080     TupleDesc   resultDesc ;     /* result type; NULL = doesn't return tuples */

00081     struct OverrideSearchPath * search_path ;     /* saved search_path */

00082     MemoryContext context ;       /* memory context holding all above */

00083     /* These fields describe the current analyzed-and-rewritten query tree: */

00084     List       * query_list ;     /* list of Query nodes, or NIL if not valid */

00085     List       * relationOids ;   /* OIDs of relations the queries depend on */

00086     List       * invalItems ;     /* other dependencies, as PlanInvalItems */

00087     MemoryContext query_context ;     /* context holding the above, or NULL */

00088     /* If we have a generic plan, this is a reference-counted link to it: */

00089     struct CachedPlan * gplan ;   /* generic plan, or NULL if not valid */

00090     /* Some state flags: */

00091     bool        is_complete ;     /* has CompleteCachedPlan been done? */

00092     bool        is_saved ;       /* has CachedPlanSource been "saved"? */

00093     bool        is_valid ;       /* is the query_list currently valid? */

00094     int         generation ;     /* increments each time we create a plan */

00095     /* If CachedPlanSource has been saved, it is a member of a global list */

00096     struct CachedPlanSource * next_saved ;         /* list link, if so */

00097     /* State kept to help decide whether to use custom or generic plans: */

00098     double      generic_cost ;   /* cost of generic plan, or -1 if not known */

00099     double      total_custom_cost ;       /* total cost of custom plans so far */

00100     int         num_custom_plans ;       /* number of plans included in total */

00101 } CachedPlanSource ;

00102  generic plan 存储在以下数据结构中:

00103 /*

00104  * CachedPlan represents an execution plan derived from a CachedPlanSource.

00105  * The reference count includes both the link from the parent CachedPlanSource

00106  * (if any), and any active plan executions, so the plan can be discarded

00107  * exactly when refcount goes to zero.  Both the struct itself and the

00108  * subsidiary data live in the context denoted by the context field.

00109  * This makes it easy to free a no-longer-needed cached plan.

00110  */

00111 typedef struct CachedPlan

00112 {

00113     int         magic ;           /* should equal CACHEDPLAN_MAGIC */

00114     List       * stmt_list ;       /* list of statement nodes (PlannedStmts and

00115                                  * bare utility statements) */

00116     bool        is_saved ;       /* is CachedPlan in a long-lived context? */

00117     bool        is_valid ;       /* is the stmt_list currently valid? */

00118     TransactionId saved_xmin ;   /* if valid, replan when TransactionXmin

00119                                  * changes from this value */

00120     int         generation ;     /* parent's generation number for this plan */

00121     int         refcount ;       /* count of live references to this struct */

00122     MemoryContext context ;       /* context containing this CachedPlan */

00123 } CachedPlan ;