Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * plancache.c
4 : * Plan cache management.
5 : *
6 : * The plan cache manager has two principal responsibilities: deciding when
7 : * to use a generic plan versus a custom (parameter-value-specific) plan,
8 : * and tracking whether cached plans need to be invalidated because of schema
9 : * changes in the objects they depend on.
10 : *
11 : * The logic for choosing generic or custom plans is in choose_custom_plan,
12 : * which see for comments.
13 : *
14 : * Cache invalidation is driven off sinval events. Any CachedPlanSource
15 : * that matches the event is marked invalid, as is its generic CachedPlan
16 : * if it has one. When (and if) the next demand for a cached plan occurs,
17 : * parse analysis and rewrite is repeated to build a new valid query tree,
18 : * and then planning is performed as normal. We also force re-analysis and
19 : * re-planning if the active search_path is different from the previous time
20 : * or, if RLS is involved, if the user changes or the RLS environment changes.
21 : *
22 : * Note that if the sinval was a result of user DDL actions, parse analysis
23 : * could throw an error, for example if a column referenced by the query is
24 : * no longer present. Another possibility is for the query's output tupdesc
25 : * to change (for instance "SELECT *" might expand differently than before).
26 : * The creator of a cached plan can specify whether it is allowable for the
27 : * query to change output tupdesc on replan --- if so, it's up to the
28 : * caller to notice changes and cope with them.
29 : *
30 : * Currently, we track exactly the dependencies of plans on relations,
31 : * user-defined functions, and domains. On relcache invalidation events or
32 : * pg_proc or pg_type syscache invalidation events, we invalidate just those
33 : * plans that depend on the particular object being modified. (Note: this
34 : * scheme assumes that any table modification that requires replanning will
35 : * generate a relcache inval event.) We also watch for inval events on
36 : * certain other system catalogs, such as pg_namespace; but for them, our
37 : * response is just to invalidate all plans. We expect updates on those
38 : * catalogs to be infrequent enough that more-detailed tracking is not worth
39 : * the effort.
40 : *
41 : * In addition to full-fledged query plans, we provide a facility for
42 : * detecting invalidations of simple scalar expressions. This is fairly
43 : * bare-bones; it's the caller's responsibility to build a new expression
44 : * if the old one gets invalidated.
45 : *
46 : *
47 : * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
48 : * Portions Copyright (c) 1994, Regents of the University of California
49 : *
50 : * IDENTIFICATION
51 : * src/backend/utils/cache/plancache.c
52 : *
53 : *-------------------------------------------------------------------------
54 : */
55 : #include "postgres.h"
56 :
57 : #include <limits.h>
58 :
59 : #include "access/transam.h"
60 : #include "catalog/namespace.h"
61 : #include "executor/executor.h"
62 : #include "miscadmin.h"
63 : #include "nodes/nodeFuncs.h"
64 : #include "optimizer/optimizer.h"
65 : #include "parser/analyze.h"
66 : #include "storage/lmgr.h"
67 : #include "tcop/pquery.h"
68 : #include "tcop/utility.h"
69 : #include "utils/inval.h"
70 : #include "utils/memutils.h"
71 : #include "utils/resowner.h"
72 : #include "utils/rls.h"
73 : #include "utils/snapmgr.h"
74 : #include "utils/syscache.h"
75 :
76 :
77 : /*
78 : * We must skip "overhead" operations that involve database access when the
79 : * cached plan's subject statement is a transaction control command or one
80 : * that requires a snapshot not to be set yet (such as SET or LOCK). More
81 : * generally, statements that do not require parse analysis/rewrite/plan
82 : * activity never need to be revalidated, so we can treat them all like that.
83 : * For the convenience of postgres.c, treat empty statements that way too.
84 : */
85 : #define StmtPlanRequiresRevalidation(plansource) \
86 : ((plansource)->raw_parse_tree != NULL && \
87 : stmt_requires_parse_analysis((plansource)->raw_parse_tree))
88 :
89 : /*
90 : * This is the head of the backend's list of "saved" CachedPlanSources (i.e.,
91 : * those that are in long-lived storage and are examined for sinval events).
92 : * We use a dlist instead of separate List cells so that we can guarantee
93 : * to save a CachedPlanSource without error.
94 : */
95 : static dlist_head saved_plan_list = DLIST_STATIC_INIT(saved_plan_list);
96 :
97 : /*
98 : * This is the head of the backend's list of CachedExpressions.
99 : */
100 : static dlist_head cached_expression_list = DLIST_STATIC_INIT(cached_expression_list);
101 :
102 : static void ReleaseGenericPlan(CachedPlanSource *plansource);
103 : static List *RevalidateCachedQuery(CachedPlanSource *plansource,
104 : QueryEnvironment *queryEnv);
105 : static bool CheckCachedPlan(CachedPlanSource *plansource);
106 : static CachedPlan *BuildCachedPlan(CachedPlanSource *plansource, List *qlist,
107 : ParamListInfo boundParams, QueryEnvironment *queryEnv);
108 : static bool choose_custom_plan(CachedPlanSource *plansource,
109 : ParamListInfo boundParams);
110 : static double cached_plan_cost(CachedPlan *plan, bool include_planner);
111 : static Query *QueryListGetPrimaryStmt(List *stmts);
112 : static void AcquireExecutorLocks(List *stmt_list, bool acquire);
113 : static void AcquirePlannerLocks(List *stmt_list, bool acquire);
114 : static void ScanQueryForLocks(Query *parsetree, bool acquire);
115 : static bool ScanQueryWalker(Node *node, bool *acquire);
116 : static TupleDesc PlanCacheComputeResultDesc(List *stmt_list);
117 : static void PlanCacheRelCallback(Datum arg, Oid relid);
118 : static void PlanCacheObjectCallback(Datum arg, int cacheid, uint32 hashvalue);
119 : static void PlanCacheSysCallback(Datum arg, int cacheid, uint32 hashvalue);
120 :
121 : /* ResourceOwner callbacks to track plancache references */
122 : static void ResOwnerReleaseCachedPlan(Datum res);
123 :
124 : static const ResourceOwnerDesc planref_resowner_desc =
125 : {
126 : .name = "plancache reference",
127 : .release_phase = RESOURCE_RELEASE_AFTER_LOCKS,
128 : .release_priority = RELEASE_PRIO_PLANCACHE_REFS,
129 : .ReleaseResource = ResOwnerReleaseCachedPlan,
130 : .DebugPrint = NULL /* the default message is fine */
131 : };
132 :
133 : /* Convenience wrappers over ResourceOwnerRemember/Forget */
134 : static inline void
135 178286 : ResourceOwnerRememberPlanCacheRef(ResourceOwner owner, CachedPlan *plan)
136 : {
137 178286 : ResourceOwnerRemember(owner, PointerGetDatum(plan), &planref_resowner_desc);
138 178286 : }
139 : static inline void
140 99752 : ResourceOwnerForgetPlanCacheRef(ResourceOwner owner, CachedPlan *plan)
141 : {
142 99752 : ResourceOwnerForget(owner, PointerGetDatum(plan), &planref_resowner_desc);
143 99752 : }
144 :
145 :
146 : /* GUC parameter */
147 : int plan_cache_mode = PLAN_CACHE_MODE_AUTO;
148 :
149 : /*
150 : * InitPlanCache: initialize module during InitPostgres.
151 : *
152 : * All we need to do is hook into inval.c's callback lists.
153 : */
154 : void
155 28540 : InitPlanCache(void)
156 : {
157 28540 : CacheRegisterRelcacheCallback(PlanCacheRelCallback, (Datum) 0);
158 28540 : CacheRegisterSyscacheCallback(PROCOID, PlanCacheObjectCallback, (Datum) 0);
159 28540 : CacheRegisterSyscacheCallback(TYPEOID, PlanCacheObjectCallback, (Datum) 0);
160 28540 : CacheRegisterSyscacheCallback(NAMESPACEOID, PlanCacheSysCallback, (Datum) 0);
161 28540 : CacheRegisterSyscacheCallback(OPEROID, PlanCacheSysCallback, (Datum) 0);
162 28540 : CacheRegisterSyscacheCallback(AMOPOPID, PlanCacheSysCallback, (Datum) 0);
163 28540 : CacheRegisterSyscacheCallback(FOREIGNSERVEROID, PlanCacheSysCallback, (Datum) 0);
164 28540 : CacheRegisterSyscacheCallback(FOREIGNDATAWRAPPEROID, PlanCacheSysCallback, (Datum) 0);
165 28540 : }
166 :
167 : /*
168 : * CreateCachedPlan: initially create a plan cache entry.
169 : *
170 : * Creation of a cached plan is divided into two steps, CreateCachedPlan and
171 : * CompleteCachedPlan. CreateCachedPlan should be called after running the
172 : * query through raw_parser, but before doing parse analysis and rewrite;
173 : * CompleteCachedPlan is called after that. The reason for this arrangement
174 : * is that it can save one round of copying of the raw parse tree, since
175 : * the parser will normally scribble on the raw parse tree. Callers would
176 : * otherwise need to make an extra copy of the parse tree to ensure they
177 : * still had a clean copy to present at plan cache creation time.
178 : *
179 : * All arguments presented to CreateCachedPlan are copied into a memory
180 : * context created as a child of the call-time CurrentMemoryContext, which
181 : * should be a reasonably short-lived working context that will go away in
182 : * event of an error. This ensures that the cached plan data structure will
183 : * likewise disappear if an error occurs before we have fully constructed it.
184 : * Once constructed, the cached plan can be made longer-lived, if needed,
185 : * by calling SaveCachedPlan.
186 : *
187 : * raw_parse_tree: output of raw_parser(), or NULL if empty query
188 : * query_string: original query text
189 : * commandTag: command tag for query, or UNKNOWN if empty query
190 : */
191 : CachedPlanSource *
192 50802 : CreateCachedPlan(RawStmt *raw_parse_tree,
193 : const char *query_string,
194 : CommandTag commandTag)
195 : {
196 : CachedPlanSource *plansource;
197 : MemoryContext source_context;
198 : MemoryContext oldcxt;
199 :
200 : Assert(query_string != NULL); /* required as of 8.4 */
201 :
202 : /*
203 : * Make a dedicated memory context for the CachedPlanSource and its
204 : * permanent subsidiary data. It's probably not going to be large, but
205 : * just in case, allow it to grow large. Initially it's a child of the
206 : * caller's context (which we assume to be transient), so that it will be
207 : * cleaned up on error.
208 : */
209 50802 : source_context = AllocSetContextCreate(CurrentMemoryContext,
210 : "CachedPlanSource",
211 : ALLOCSET_START_SMALL_SIZES);
212 :
213 : /*
214 : * Create and fill the CachedPlanSource struct within the new context.
215 : * Most fields are just left empty for the moment.
216 : */
217 50802 : oldcxt = MemoryContextSwitchTo(source_context);
218 :
219 50802 : plansource = (CachedPlanSource *) palloc0(sizeof(CachedPlanSource));
220 50802 : plansource->magic = CACHEDPLANSOURCE_MAGIC;
221 50802 : plansource->raw_parse_tree = copyObject(raw_parse_tree);
222 50802 : plansource->query_string = pstrdup(query_string);
223 50802 : MemoryContextSetIdentifier(source_context, plansource->query_string);
224 50802 : plansource->commandTag = commandTag;
225 50802 : plansource->param_types = NULL;
226 50802 : plansource->num_params = 0;
227 50802 : plansource->parserSetup = NULL;
228 50802 : plansource->parserSetupArg = NULL;
229 50802 : plansource->cursor_options = 0;
230 50802 : plansource->fixed_result = false;
231 50802 : plansource->resultDesc = NULL;
232 50802 : plansource->context = source_context;
233 50802 : plansource->query_list = NIL;
234 50802 : plansource->relationOids = NIL;
235 50802 : plansource->invalItems = NIL;
236 50802 : plansource->search_path = NULL;
237 50802 : plansource->query_context = NULL;
238 50802 : plansource->rewriteRoleId = InvalidOid;
239 50802 : plansource->rewriteRowSecurity = false;
240 50802 : plansource->dependsOnRLS = false;
241 50802 : plansource->gplan = NULL;
242 50802 : plansource->is_oneshot = false;
243 50802 : plansource->is_complete = false;
244 50802 : plansource->is_saved = false;
245 50802 : plansource->is_valid = false;
246 50802 : plansource->generation = 0;
247 50802 : plansource->generic_cost = -1;
248 50802 : plansource->total_custom_cost = 0;
249 50802 : plansource->num_generic_plans = 0;
250 50802 : plansource->num_custom_plans = 0;
251 :
252 50802 : MemoryContextSwitchTo(oldcxt);
253 :
254 50802 : return plansource;
255 : }
256 :
257 : /*
258 : * CreateOneShotCachedPlan: initially create a one-shot plan cache entry.
259 : *
260 : * This variant of CreateCachedPlan creates a plan cache entry that is meant
261 : * to be used only once. No data copying occurs: all data structures remain
262 : * in the caller's memory context (which typically should get cleared after
263 : * completing execution). The CachedPlanSource struct itself is also created
264 : * in that context.
265 : *
266 : * A one-shot plan cannot be saved or copied, since we make no effort to
267 : * preserve the raw parse tree unmodified. There is also no support for
268 : * invalidation, so plan use must be completed in the current transaction,
269 : * and DDL that might invalidate the querytree_list must be avoided as well.
270 : *
271 : * raw_parse_tree: output of raw_parser(), or NULL if empty query
272 : * query_string: original query text
273 : * commandTag: command tag for query, or NULL if empty query
274 : */
275 : CachedPlanSource *
276 12510 : CreateOneShotCachedPlan(RawStmt *raw_parse_tree,
277 : const char *query_string,
278 : CommandTag commandTag)
279 : {
280 : CachedPlanSource *plansource;
281 :
282 : Assert(query_string != NULL); /* required as of 8.4 */
283 :
284 : /*
285 : * Create and fill the CachedPlanSource struct within the caller's memory
286 : * context. Most fields are just left empty for the moment.
287 : */
288 12510 : plansource = (CachedPlanSource *) palloc0(sizeof(CachedPlanSource));
289 12510 : plansource->magic = CACHEDPLANSOURCE_MAGIC;
290 12510 : plansource->raw_parse_tree = raw_parse_tree;
291 12510 : plansource->query_string = query_string;
292 12510 : plansource->commandTag = commandTag;
293 12510 : plansource->param_types = NULL;
294 12510 : plansource->num_params = 0;
295 12510 : plansource->parserSetup = NULL;
296 12510 : plansource->parserSetupArg = NULL;
297 12510 : plansource->cursor_options = 0;
298 12510 : plansource->fixed_result = false;
299 12510 : plansource->resultDesc = NULL;
300 12510 : plansource->context = CurrentMemoryContext;
301 12510 : plansource->query_list = NIL;
302 12510 : plansource->relationOids = NIL;
303 12510 : plansource->invalItems = NIL;
304 12510 : plansource->search_path = NULL;
305 12510 : plansource->query_context = NULL;
306 12510 : plansource->rewriteRoleId = InvalidOid;
307 12510 : plansource->rewriteRowSecurity = false;
308 12510 : plansource->dependsOnRLS = false;
309 12510 : plansource->gplan = NULL;
310 12510 : plansource->is_oneshot = true;
311 12510 : plansource->is_complete = false;
312 12510 : plansource->is_saved = false;
313 12510 : plansource->is_valid = false;
314 12510 : plansource->generation = 0;
315 12510 : plansource->generic_cost = -1;
316 12510 : plansource->total_custom_cost = 0;
317 12510 : plansource->num_generic_plans = 0;
318 12510 : plansource->num_custom_plans = 0;
319 :
320 12510 : return plansource;
321 : }
322 :
323 : /*
324 : * CompleteCachedPlan: second step of creating a plan cache entry.
325 : *
326 : * Pass in the analyzed-and-rewritten form of the query, as well as the
327 : * required subsidiary data about parameters and such. All passed values will
328 : * be copied into the CachedPlanSource's memory, except as specified below.
329 : * After this is called, GetCachedPlan can be called to obtain a plan, and
330 : * optionally the CachedPlanSource can be saved using SaveCachedPlan.
331 : *
332 : * If querytree_context is not NULL, the querytree_list must be stored in that
333 : * context (but the other parameters need not be). The querytree_list is not
334 : * copied, rather the given context is kept as the initial query_context of
335 : * the CachedPlanSource. (It should have been created as a child of the
336 : * caller's working memory context, but it will now be reparented to belong
337 : * to the CachedPlanSource.) The querytree_context is normally the context in
338 : * which the caller did raw parsing and parse analysis. This approach saves
339 : * one tree copying step compared to passing NULL, but leaves lots of extra
340 : * cruft in the query_context, namely whatever extraneous stuff parse analysis
341 : * created, as well as whatever went unused from the raw parse tree. Using
342 : * this option is a space-for-time tradeoff that is appropriate if the
343 : * CachedPlanSource is not expected to survive long.
344 : *
345 : * plancache.c cannot know how to copy the data referenced by parserSetupArg,
346 : * and it would often be inappropriate to do so anyway. When using that
347 : * option, it is caller's responsibility that the referenced data remains
348 : * valid for as long as the CachedPlanSource exists.
349 : *
350 : * If the CachedPlanSource is a "oneshot" plan, then no querytree copying
351 : * occurs at all, and querytree_context is ignored; it is caller's
352 : * responsibility that the passed querytree_list is sufficiently long-lived.
353 : *
354 : * plansource: structure returned by CreateCachedPlan
355 : * querytree_list: analyzed-and-rewritten form of query (list of Query nodes)
356 : * querytree_context: memory context containing querytree_list,
357 : * or NULL to copy querytree_list into a fresh context
358 : * param_types: array of fixed parameter type OIDs, or NULL if none
359 : * num_params: number of fixed parameters
360 : * parserSetup: alternate method for handling query parameters
361 : * parserSetupArg: data to pass to parserSetup
362 : * cursor_options: options bitmask to pass to planner
363 : * fixed_result: true to disallow future changes in query's result tupdesc
364 : */
365 : void
366 63186 : CompleteCachedPlan(CachedPlanSource *plansource,
367 : List *querytree_list,
368 : MemoryContext querytree_context,
369 : Oid *param_types,
370 : int num_params,
371 : ParserSetupHook parserSetup,
372 : void *parserSetupArg,
373 : int cursor_options,
374 : bool fixed_result)
375 : {
376 63186 : MemoryContext source_context = plansource->context;
377 63186 : MemoryContext oldcxt = CurrentMemoryContext;
378 :
379 : /* Assert caller is doing things in a sane order */
380 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
381 : Assert(!plansource->is_complete);
382 :
383 : /*
384 : * If caller supplied a querytree_context, reparent it underneath the
385 : * CachedPlanSource's context; otherwise, create a suitable context and
386 : * copy the querytree_list into it. But no data copying should be done
387 : * for one-shot plans; for those, assume the passed querytree_list is
388 : * sufficiently long-lived.
389 : */
390 63186 : if (plansource->is_oneshot)
391 : {
392 12494 : querytree_context = CurrentMemoryContext;
393 : }
394 50692 : else if (querytree_context != NULL)
395 : {
396 5802 : MemoryContextSetParent(querytree_context, source_context);
397 5802 : MemoryContextSwitchTo(querytree_context);
398 : }
399 : else
400 : {
401 : /* Again, it's a good bet the querytree_context can be small */
402 44890 : querytree_context = AllocSetContextCreate(source_context,
403 : "CachedPlanQuery",
404 : ALLOCSET_START_SMALL_SIZES);
405 44890 : MemoryContextSwitchTo(querytree_context);
406 44890 : querytree_list = copyObject(querytree_list);
407 : }
408 :
409 63186 : plansource->query_context = querytree_context;
410 63186 : plansource->query_list = querytree_list;
411 :
412 63186 : if (!plansource->is_oneshot && StmtPlanRequiresRevalidation(plansource))
413 : {
414 : /*
415 : * Use the planner machinery to extract dependencies. Data is saved
416 : * in query_context. (We assume that not a lot of extra cruft is
417 : * created by this call.) We can skip this for one-shot plans, and
418 : * plans not needing revalidation have no such dependencies anyway.
419 : */
420 49876 : extract_query_dependencies((Node *) querytree_list,
421 : &plansource->relationOids,
422 : &plansource->invalItems,
423 : &plansource->dependsOnRLS);
424 :
425 : /* Update RLS info as well. */
426 49876 : plansource->rewriteRoleId = GetUserId();
427 49876 : plansource->rewriteRowSecurity = row_security;
428 :
429 : /*
430 : * Also save the current search_path in the query_context. (This
431 : * should not generate much extra cruft either, since almost certainly
432 : * the path is already valid.) Again, we don't really need this for
433 : * one-shot plans; and we *must* skip this for transaction control
434 : * commands, because this could result in catalog accesses.
435 : */
436 49876 : plansource->search_path = GetSearchPathMatcher(querytree_context);
437 : }
438 :
439 : /*
440 : * Save the final parameter types (or other parameter specification data)
441 : * into the source_context, as well as our other parameters. Also save
442 : * the result tuple descriptor.
443 : */
444 63186 : MemoryContextSwitchTo(source_context);
445 :
446 63186 : if (num_params > 0)
447 : {
448 13370 : plansource->param_types = (Oid *) palloc(num_params * sizeof(Oid));
449 13370 : memcpy(plansource->param_types, param_types, num_params * sizeof(Oid));
450 : }
451 : else
452 49816 : plansource->param_types = NULL;
453 63186 : plansource->num_params = num_params;
454 63186 : plansource->parserSetup = parserSetup;
455 63186 : plansource->parserSetupArg = parserSetupArg;
456 63186 : plansource->cursor_options = cursor_options;
457 63186 : plansource->fixed_result = fixed_result;
458 63186 : plansource->resultDesc = PlanCacheComputeResultDesc(querytree_list);
459 :
460 63186 : MemoryContextSwitchTo(oldcxt);
461 :
462 63186 : plansource->is_complete = true;
463 63186 : plansource->is_valid = true;
464 63186 : }
465 :
466 : /*
467 : * SaveCachedPlan: save a cached plan permanently
468 : *
469 : * This function moves the cached plan underneath CacheMemoryContext (making
470 : * it live for the life of the backend, unless explicitly dropped), and adds
471 : * it to the list of cached plans that are checked for invalidation when an
472 : * sinval event occurs.
473 : *
474 : * This is guaranteed not to throw error, except for the caller-error case
475 : * of trying to save a one-shot plan. Callers typically depend on that
476 : * since this is called just before or just after adding a pointer to the
477 : * CachedPlanSource to some permanent data structure of their own. Up until
478 : * this is done, a CachedPlanSource is just transient data that will go away
479 : * automatically on transaction abort.
480 : */
481 : void
482 40076 : SaveCachedPlan(CachedPlanSource *plansource)
483 : {
484 : /* Assert caller is doing things in a sane order */
485 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
486 : Assert(plansource->is_complete);
487 : Assert(!plansource->is_saved);
488 :
489 : /* This seems worth a real test, though */
490 40076 : if (plansource->is_oneshot)
491 0 : elog(ERROR, "cannot save one-shot cached plan");
492 :
493 : /*
494 : * In typical use, this function would be called before generating any
495 : * plans from the CachedPlanSource. If there is a generic plan, moving it
496 : * into CacheMemoryContext would be pretty risky since it's unclear
497 : * whether the caller has taken suitable care with making references
498 : * long-lived. Best thing to do seems to be to discard the plan.
499 : */
500 40076 : ReleaseGenericPlan(plansource);
501 :
502 : /*
503 : * Reparent the source memory context under CacheMemoryContext so that it
504 : * will live indefinitely. The query_context follows along since it's
505 : * already a child of the other one.
506 : */
507 40076 : MemoryContextSetParent(plansource->context, CacheMemoryContext);
508 :
509 : /*
510 : * Add the entry to the global list of cached plans.
511 : */
512 40076 : dlist_push_tail(&saved_plan_list, &plansource->node);
513 :
514 40076 : plansource->is_saved = true;
515 40076 : }
516 :
517 : /*
518 : * DropCachedPlan: destroy a cached plan.
519 : *
520 : * Actually this only destroys the CachedPlanSource: any referenced CachedPlan
521 : * is released, but not destroyed until its refcount goes to zero. That
522 : * handles the situation where DropCachedPlan is called while the plan is
523 : * still in use.
524 : */
525 : void
526 14910 : DropCachedPlan(CachedPlanSource *plansource)
527 : {
528 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
529 :
530 : /* If it's been saved, remove it from the list */
531 14910 : if (plansource->is_saved)
532 : {
533 14720 : dlist_delete(&plansource->node);
534 14720 : plansource->is_saved = false;
535 : }
536 :
537 : /* Decrement generic CachedPlan's refcount and drop if no longer needed */
538 14910 : ReleaseGenericPlan(plansource);
539 :
540 : /* Mark it no longer valid */
541 14910 : plansource->magic = 0;
542 :
543 : /*
544 : * Remove the CachedPlanSource and all subsidiary data (including the
545 : * query_context if any). But if it's a one-shot we can't free anything.
546 : */
547 14910 : if (!plansource->is_oneshot)
548 14910 : MemoryContextDelete(plansource->context);
549 14910 : }
550 :
551 : /*
552 : * ReleaseGenericPlan: release a CachedPlanSource's generic plan, if any.
553 : */
554 : static void
555 104378 : ReleaseGenericPlan(CachedPlanSource *plansource)
556 : {
557 : /* Be paranoid about the possibility that ReleaseCachedPlan fails */
558 104378 : if (plansource->gplan)
559 : {
560 12222 : CachedPlan *plan = plansource->gplan;
561 :
562 : Assert(plan->magic == CACHEDPLAN_MAGIC);
563 12222 : plansource->gplan = NULL;
564 12222 : ReleaseCachedPlan(plan, NULL);
565 : }
566 104378 : }
567 :
568 : /*
569 : * RevalidateCachedQuery: ensure validity of analyzed-and-rewritten query tree.
570 : *
571 : * What we do here is re-acquire locks and redo parse analysis if necessary.
572 : * On return, the query_list is valid and we have sufficient locks to begin
573 : * planning.
574 : *
575 : * If any parse analysis activity is required, the caller's memory context is
576 : * used for that work.
577 : *
578 : * The result value is the transient analyzed-and-rewritten query tree if we
579 : * had to do re-analysis, and NIL otherwise. (This is returned just to save
580 : * a tree copying step in a subsequent BuildCachedPlan call.)
581 : */
582 : static List *
583 170856 : RevalidateCachedQuery(CachedPlanSource *plansource,
584 : QueryEnvironment *queryEnv)
585 : {
586 : bool snapshot_set;
587 : RawStmt *rawtree;
588 : List *tlist; /* transient query-tree list */
589 : List *qlist; /* permanent query-tree list */
590 : TupleDesc resultDesc;
591 : MemoryContext querytree_context;
592 : MemoryContext oldcxt;
593 :
594 : /*
595 : * For one-shot plans, we do not support revalidation checking; it's
596 : * assumed the query is parsed, planned, and executed in one transaction,
597 : * so that no lock re-acquisition is necessary. Also, if the statement
598 : * type can't require revalidation, we needn't do anything (and we mustn't
599 : * risk catalog accesses when handling, eg, transaction control commands).
600 : */
601 170856 : if (plansource->is_oneshot || !StmtPlanRequiresRevalidation(plansource))
602 : {
603 : Assert(plansource->is_valid);
604 24756 : return NIL;
605 : }
606 :
607 : /*
608 : * If the query is currently valid, we should have a saved search_path ---
609 : * check to see if that matches the current environment. If not, we want
610 : * to force replan.
611 : */
612 146100 : if (plansource->is_valid)
613 : {
614 : Assert(plansource->search_path != NULL);
615 140092 : if (!SearchPathMatchesCurrentEnvironment(plansource->search_path))
616 : {
617 : /* Invalidate the querytree and generic plan */
618 152 : plansource->is_valid = false;
619 152 : if (plansource->gplan)
620 146 : plansource->gplan->is_valid = false;
621 : }
622 : }
623 :
624 : /*
625 : * If the query rewrite phase had a possible RLS dependency, we must redo
626 : * it if either the role or the row_security setting has changed.
627 : */
628 146354 : if (plansource->is_valid && plansource->dependsOnRLS &&
629 254 : (plansource->rewriteRoleId != GetUserId() ||
630 180 : plansource->rewriteRowSecurity != row_security))
631 74 : plansource->is_valid = false;
632 :
633 : /*
634 : * If the query is currently valid, acquire locks on the referenced
635 : * objects; then check again. We need to do it this way to cover the race
636 : * condition that an invalidation message arrives before we get the locks.
637 : */
638 146100 : if (plansource->is_valid)
639 : {
640 139866 : AcquirePlannerLocks(plansource->query_list, true);
641 :
642 : /*
643 : * By now, if any invalidation has happened, the inval callback
644 : * functions will have marked the query invalid.
645 : */
646 139866 : if (plansource->is_valid)
647 : {
648 : /* Successfully revalidated and locked the query. */
649 139850 : return NIL;
650 : }
651 :
652 : /* Oops, the race case happened. Release useless locks. */
653 16 : AcquirePlannerLocks(plansource->query_list, false);
654 : }
655 :
656 : /*
657 : * Discard the no-longer-useful query tree. (Note: we don't want to do
658 : * this any earlier, else we'd not have been able to release locks
659 : * correctly in the race condition case.)
660 : */
661 6250 : plansource->is_valid = false;
662 6250 : plansource->query_list = NIL;
663 6250 : plansource->relationOids = NIL;
664 6250 : plansource->invalItems = NIL;
665 6250 : plansource->search_path = NULL;
666 :
667 : /*
668 : * Free the query_context. We don't really expect MemoryContextDelete to
669 : * fail, but just in case, make sure the CachedPlanSource is left in a
670 : * reasonably sane state. (The generic plan won't get unlinked yet, but
671 : * that's acceptable.)
672 : */
673 6250 : if (plansource->query_context)
674 : {
675 6226 : MemoryContext qcxt = plansource->query_context;
676 :
677 6226 : plansource->query_context = NULL;
678 6226 : MemoryContextDelete(qcxt);
679 : }
680 :
681 : /* Drop the generic plan reference if any */
682 6250 : ReleaseGenericPlan(plansource);
683 :
684 : /*
685 : * Now re-do parse analysis and rewrite. This not incidentally acquires
686 : * the locks we need to do planning safely.
687 : */
688 : Assert(plansource->is_complete);
689 :
690 : /*
691 : * If a snapshot is already set (the normal case), we can just use that
692 : * for parsing/planning. But if it isn't, install one. Note: no point in
693 : * checking whether parse analysis requires a snapshot; utility commands
694 : * don't have invalidatable plans, so we'd not get here for such a
695 : * command.
696 : */
697 6250 : snapshot_set = false;
698 6250 : if (!ActiveSnapshotSet())
699 : {
700 20 : PushActiveSnapshot(GetTransactionSnapshot());
701 20 : snapshot_set = true;
702 : }
703 :
704 : /*
705 : * Run parse analysis and rule rewriting. The parser tends to scribble on
706 : * its input, so we must copy the raw parse tree to prevent corruption of
707 : * the cache.
708 : */
709 6250 : rawtree = copyObject(plansource->raw_parse_tree);
710 6250 : if (rawtree == NULL)
711 0 : tlist = NIL;
712 6250 : else if (plansource->parserSetup != NULL)
713 5856 : tlist = pg_analyze_and_rewrite_withcb(rawtree,
714 : plansource->query_string,
715 : plansource->parserSetup,
716 : plansource->parserSetupArg,
717 : queryEnv);
718 : else
719 394 : tlist = pg_analyze_and_rewrite_fixedparams(rawtree,
720 : plansource->query_string,
721 394 : plansource->param_types,
722 : plansource->num_params,
723 : queryEnv);
724 :
725 : /* Release snapshot if we got one */
726 6224 : if (snapshot_set)
727 20 : PopActiveSnapshot();
728 :
729 : /*
730 : * Check or update the result tupdesc.
731 : *
732 : * We assume the parameter types didn't change from the first time, so no
733 : * need to update that.
734 : */
735 6224 : resultDesc = PlanCacheComputeResultDesc(tlist);
736 6224 : if (resultDesc == NULL && plansource->resultDesc == NULL)
737 : {
738 : /* OK, doesn't return tuples */
739 : }
740 6056 : else if (resultDesc == NULL || plansource->resultDesc == NULL ||
741 6056 : !equalRowTypes(resultDesc, plansource->resultDesc))
742 : {
743 : /* can we give a better error message? */
744 58 : if (plansource->fixed_result)
745 12 : ereport(ERROR,
746 : (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
747 : errmsg("cached plan must not change result type")));
748 46 : oldcxt = MemoryContextSwitchTo(plansource->context);
749 46 : if (resultDesc)
750 46 : resultDesc = CreateTupleDescCopy(resultDesc);
751 46 : if (plansource->resultDesc)
752 46 : FreeTupleDesc(plansource->resultDesc);
753 46 : plansource->resultDesc = resultDesc;
754 46 : MemoryContextSwitchTo(oldcxt);
755 : }
756 :
757 : /*
758 : * Allocate new query_context and copy the completed querytree into it.
759 : * It's transient until we complete the copying and dependency extraction.
760 : */
761 6212 : querytree_context = AllocSetContextCreate(CurrentMemoryContext,
762 : "CachedPlanQuery",
763 : ALLOCSET_START_SMALL_SIZES);
764 6212 : oldcxt = MemoryContextSwitchTo(querytree_context);
765 :
766 6212 : qlist = copyObject(tlist);
767 :
768 : /*
769 : * Use the planner machinery to extract dependencies. Data is saved in
770 : * query_context. (We assume that not a lot of extra cruft is created by
771 : * this call.)
772 : */
773 6212 : extract_query_dependencies((Node *) qlist,
774 : &plansource->relationOids,
775 : &plansource->invalItems,
776 : &plansource->dependsOnRLS);
777 :
778 : /* Update RLS info as well. */
779 6212 : plansource->rewriteRoleId = GetUserId();
780 6212 : plansource->rewriteRowSecurity = row_security;
781 :
782 : /*
783 : * Also save the current search_path in the query_context. (This should
784 : * not generate much extra cruft either, since almost certainly the path
785 : * is already valid.)
786 : */
787 6212 : plansource->search_path = GetSearchPathMatcher(querytree_context);
788 :
789 6212 : MemoryContextSwitchTo(oldcxt);
790 :
791 : /* Now reparent the finished query_context and save the links */
792 6212 : MemoryContextSetParent(querytree_context, plansource->context);
793 :
794 6212 : plansource->query_context = querytree_context;
795 6212 : plansource->query_list = qlist;
796 :
797 : /*
798 : * Note: we do not reset generic_cost or total_custom_cost, although we
799 : * could choose to do so. If the DDL or statistics change that prompted
800 : * the invalidation meant a significant change in the cost estimates, it
801 : * would be better to reset those variables and start fresh; but often it
802 : * doesn't, and we're better retaining our hard-won knowledge about the
803 : * relative costs.
804 : */
805 :
806 6212 : plansource->is_valid = true;
807 :
808 : /* Return transient copy of querytrees for possible use in planning */
809 6212 : return tlist;
810 : }
811 :
812 : /*
813 : * CheckCachedPlan: see if the CachedPlanSource's generic plan is valid.
814 : *
815 : * Caller must have already called RevalidateCachedQuery to verify that the
816 : * querytree is up to date.
817 : *
818 : * On a "true" return, we have acquired the locks needed to run the plan.
819 : * (We must do this for the "true" result to be race-condition-free.)
820 : */
821 : static bool
822 123172 : CheckCachedPlan(CachedPlanSource *plansource)
823 : {
824 123172 : CachedPlan *plan = plansource->gplan;
825 :
826 : /* Assert that caller checked the querytree */
827 : Assert(plansource->is_valid);
828 :
829 : /* If there's no generic plan, just say "false" */
830 123172 : if (!plan)
831 43122 : return false;
832 :
833 : Assert(plan->magic == CACHEDPLAN_MAGIC);
834 : /* Generic plans are never one-shot */
835 : Assert(!plan->is_oneshot);
836 :
837 : /*
838 : * If plan isn't valid for current role, we can't use it.
839 : */
840 80060 : if (plan->is_valid && plan->dependsOnRole &&
841 10 : plan->planRoleId != GetUserId())
842 6 : plan->is_valid = false;
843 :
844 : /*
845 : * If it appears valid, acquire locks and recheck; this is much the same
846 : * logic as in RevalidateCachedQuery, but for a plan.
847 : */
848 80050 : if (plan->is_valid)
849 : {
850 : /*
851 : * Plan must have positive refcount because it is referenced by
852 : * plansource; so no need to fear it disappears under us here.
853 : */
854 : Assert(plan->refcount > 0);
855 :
856 80014 : AcquireExecutorLocks(plan->stmt_list, true);
857 :
858 : /*
859 : * If plan was transient, check to see if TransactionXmin has
860 : * advanced, and if so invalidate it.
861 : */
862 80014 : if (plan->is_valid &&
863 80014 : TransactionIdIsValid(plan->saved_xmin) &&
864 0 : !TransactionIdEquals(plan->saved_xmin, TransactionXmin))
865 0 : plan->is_valid = false;
866 :
867 : /*
868 : * By now, if any invalidation has happened, the inval callback
869 : * functions will have marked the plan invalid.
870 : */
871 80014 : if (plan->is_valid)
872 : {
873 : /* Successfully revalidated and locked the query. */
874 80014 : return true;
875 : }
876 :
877 : /* Oops, the race case happened. Release useless locks. */
878 0 : AcquireExecutorLocks(plan->stmt_list, false);
879 : }
880 :
881 : /*
882 : * Plan has been invalidated, so unlink it from the parent and release it.
883 : */
884 36 : ReleaseGenericPlan(plansource);
885 :
886 36 : return false;
887 : }
888 :
889 : /*
890 : * BuildCachedPlan: construct a new CachedPlan from a CachedPlanSource.
891 : *
892 : * qlist should be the result value from a previous RevalidateCachedQuery,
893 : * or it can be set to NIL if we need to re-copy the plansource's query_list.
894 : *
895 : * To build a generic, parameter-value-independent plan, pass NULL for
896 : * boundParams. To build a custom plan, pass the actual parameter values via
897 : * boundParams. For best effect, the PARAM_FLAG_CONST flag should be set on
898 : * each parameter value; otherwise the planner will treat the value as a
899 : * hint rather than a hard constant.
900 : *
901 : * Planning work is done in the caller's memory context. The finished plan
902 : * is in a child memory context, which typically should get reparented
903 : * (unless this is a one-shot plan, in which case we don't copy the plan).
904 : */
905 : static CachedPlan *
906 79590 : BuildCachedPlan(CachedPlanSource *plansource, List *qlist,
907 : ParamListInfo boundParams, QueryEnvironment *queryEnv)
908 : {
909 : CachedPlan *plan;
910 : List *plist;
911 : bool snapshot_set;
912 : bool is_transient;
913 : MemoryContext plan_context;
914 79590 : MemoryContext oldcxt = CurrentMemoryContext;
915 : ListCell *lc;
916 :
917 : /*
918 : * Normally the querytree should be valid already, but if it's not,
919 : * rebuild it.
920 : *
921 : * NOTE: GetCachedPlan should have called RevalidateCachedQuery first, so
922 : * we ought to be holding sufficient locks to prevent any invalidation.
923 : * However, if we're building a custom plan after having built and
924 : * rejected a generic plan, it's possible to reach here with is_valid
925 : * false due to an invalidation while making the generic plan. In theory
926 : * the invalidation must be a false positive, perhaps a consequence of an
927 : * sinval reset event or the debug_discard_caches code. But for safety,
928 : * let's treat it as real and redo the RevalidateCachedQuery call.
929 : */
930 79590 : if (!plansource->is_valid)
931 0 : qlist = RevalidateCachedQuery(plansource, queryEnv);
932 :
933 : /*
934 : * If we don't already have a copy of the querytree list that can be
935 : * scribbled on by the planner, make one. For a one-shot plan, we assume
936 : * it's okay to scribble on the original query_list.
937 : */
938 79590 : if (qlist == NIL)
939 : {
940 73380 : if (!plansource->is_oneshot)
941 60892 : qlist = copyObject(plansource->query_list);
942 : else
943 12488 : qlist = plansource->query_list;
944 : }
945 :
946 : /*
947 : * If a snapshot is already set (the normal case), we can just use that
948 : * for planning. But if it isn't, and we need one, install one.
949 : */
950 79590 : snapshot_set = false;
951 79590 : if (!ActiveSnapshotSet() &&
952 1628 : plansource->raw_parse_tree &&
953 814 : analyze_requires_snapshot(plansource->raw_parse_tree))
954 : {
955 274 : PushActiveSnapshot(GetTransactionSnapshot());
956 274 : snapshot_set = true;
957 : }
958 :
959 : /*
960 : * Generate the plan.
961 : */
962 79590 : plist = pg_plan_queries(qlist, plansource->query_string,
963 : plansource->cursor_options, boundParams);
964 :
965 : /* Release snapshot if we got one */
966 79422 : if (snapshot_set)
967 268 : PopActiveSnapshot();
968 :
969 : /*
970 : * Normally we make a dedicated memory context for the CachedPlan and its
971 : * subsidiary data. (It's probably not going to be large, but just in
972 : * case, allow it to grow large. It's transient for the moment.) But for
973 : * a one-shot plan, we just leave it in the caller's memory context.
974 : */
975 79422 : if (!plansource->is_oneshot)
976 : {
977 67010 : plan_context = AllocSetContextCreate(CurrentMemoryContext,
978 : "CachedPlan",
979 : ALLOCSET_START_SMALL_SIZES);
980 67010 : MemoryContextCopyAndSetIdentifier(plan_context, plansource->query_string);
981 :
982 : /*
983 : * Copy plan into the new context.
984 : */
985 67010 : MemoryContextSwitchTo(plan_context);
986 :
987 67010 : plist = copyObject(plist);
988 : }
989 : else
990 12412 : plan_context = CurrentMemoryContext;
991 :
992 : /*
993 : * Create and fill the CachedPlan struct within the new context.
994 : */
995 79422 : plan = (CachedPlan *) palloc(sizeof(CachedPlan));
996 79422 : plan->magic = CACHEDPLAN_MAGIC;
997 79422 : plan->stmt_list = plist;
998 :
999 : /*
1000 : * CachedPlan is dependent on role either if RLS affected the rewrite
1001 : * phase or if a role dependency was injected during planning. And it's
1002 : * transient if any plan is marked so.
1003 : */
1004 79422 : plan->planRoleId = GetUserId();
1005 79422 : plan->dependsOnRole = plansource->dependsOnRLS;
1006 79422 : is_transient = false;
1007 158844 : foreach(lc, plist)
1008 : {
1009 79422 : PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
1010 :
1011 79422 : if (plannedstmt->commandType == CMD_UTILITY)
1012 11488 : continue; /* Ignore utility statements */
1013 :
1014 67934 : if (plannedstmt->transientPlan)
1015 0 : is_transient = true;
1016 67934 : if (plannedstmt->dependsOnRole)
1017 12 : plan->dependsOnRole = true;
1018 : }
1019 79422 : if (is_transient)
1020 : {
1021 : Assert(TransactionIdIsNormal(TransactionXmin));
1022 0 : plan->saved_xmin = TransactionXmin;
1023 : }
1024 : else
1025 79422 : plan->saved_xmin = InvalidTransactionId;
1026 79422 : plan->refcount = 0;
1027 79422 : plan->context = plan_context;
1028 79422 : plan->is_oneshot = plansource->is_oneshot;
1029 79422 : plan->is_saved = false;
1030 79422 : plan->is_valid = true;
1031 :
1032 : /* assign generation number to new plan */
1033 79422 : plan->generation = ++(plansource->generation);
1034 :
1035 79422 : MemoryContextSwitchTo(oldcxt);
1036 :
1037 79422 : return plan;
1038 : }
1039 :
1040 : /*
1041 : * choose_custom_plan: choose whether to use custom or generic plan
1042 : *
1043 : * This defines the policy followed by GetCachedPlan.
1044 : */
1045 : static bool
1046 202658 : choose_custom_plan(CachedPlanSource *plansource, ParamListInfo boundParams)
1047 : {
1048 : double avg_custom_cost;
1049 :
1050 : /* One-shot plans will always be considered custom */
1051 202658 : if (plansource->is_oneshot)
1052 12488 : return true;
1053 :
1054 : /* Otherwise, never any point in a custom plan if there's no parameters */
1055 190170 : if (boundParams == NULL)
1056 121426 : return false;
1057 : /* ... nor when planning would be a no-op */
1058 68744 : if (!StmtPlanRequiresRevalidation(plansource))
1059 0 : return false;
1060 :
1061 : /* Let settings force the decision */
1062 68744 : if (plan_cache_mode == PLAN_CACHE_MODE_FORCE_GENERIC_PLAN)
1063 302 : return false;
1064 68442 : if (plan_cache_mode == PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN)
1065 6 : return true;
1066 :
1067 : /* See if caller wants to force the decision */
1068 68436 : if (plansource->cursor_options & CURSOR_OPT_GENERIC_PLAN)
1069 0 : return false;
1070 68436 : if (plansource->cursor_options & CURSOR_OPT_CUSTOM_PLAN)
1071 0 : return true;
1072 :
1073 : /* Generate custom plans until we have done at least 5 (arbitrary) */
1074 68436 : if (plansource->num_custom_plans < 5)
1075 22264 : return true;
1076 :
1077 46172 : avg_custom_cost = plansource->total_custom_cost / plansource->num_custom_plans;
1078 :
1079 : /*
1080 : * Prefer generic plan if it's less expensive than the average custom
1081 : * plan. (Because we include a charge for cost of planning in the
1082 : * custom-plan costs, this means the generic plan only has to be less
1083 : * expensive than the execution cost plus replan cost of the custom
1084 : * plans.)
1085 : *
1086 : * Note that if generic_cost is -1 (indicating we've not yet determined
1087 : * the generic plan cost), we'll always prefer generic at this point.
1088 : */
1089 46172 : if (plansource->generic_cost < avg_custom_cost)
1090 44498 : return false;
1091 :
1092 1674 : return true;
1093 : }
1094 :
1095 : /*
1096 : * cached_plan_cost: calculate estimated cost of a plan
1097 : *
1098 : * If include_planner is true, also include the estimated cost of constructing
1099 : * the plan. (We must factor that into the cost of using a custom plan, but
1100 : * we don't count it for a generic plan.)
1101 : */
1102 : static double
1103 79422 : cached_plan_cost(CachedPlan *plan, bool include_planner)
1104 : {
1105 79422 : double result = 0;
1106 : ListCell *lc;
1107 :
1108 158844 : foreach(lc, plan->stmt_list)
1109 : {
1110 79422 : PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
1111 :
1112 79422 : if (plannedstmt->commandType == CMD_UTILITY)
1113 11488 : continue; /* Ignore utility statements */
1114 :
1115 67934 : result += plannedstmt->planTree->total_cost;
1116 :
1117 67934 : if (include_planner)
1118 : {
1119 : /*
1120 : * Currently we use a very crude estimate of planning effort based
1121 : * on the number of relations in the finished plan's rangetable.
1122 : * Join planning effort actually scales much worse than linearly
1123 : * in the number of relations --- but only until the join collapse
1124 : * limits kick in. Also, while inheritance child relations surely
1125 : * add to planning effort, they don't make the join situation
1126 : * worse. So the actual shape of the planning cost curve versus
1127 : * number of relations isn't all that obvious. It will take
1128 : * considerable work to arrive at a less crude estimate, and for
1129 : * now it's not clear that's worth doing.
1130 : *
1131 : * The other big difficulty here is that we don't have any very
1132 : * good model of how planning cost compares to execution costs.
1133 : * The current multiplier of 1000 * cpu_operator_cost is probably
1134 : * on the low side, but we'll try this for awhile before making a
1135 : * more aggressive correction.
1136 : *
1137 : * If we ever do write a more complicated estimator, it should
1138 : * probably live in src/backend/optimizer/ not here.
1139 : */
1140 34442 : int nrelations = list_length(plannedstmt->rtable);
1141 :
1142 34442 : result += 1000.0 * cpu_operator_cost * (nrelations + 1);
1143 : }
1144 : }
1145 :
1146 79422 : return result;
1147 : }
1148 :
1149 : /*
1150 : * GetCachedPlan: get a cached plan from a CachedPlanSource.
1151 : *
1152 : * This function hides the logic that decides whether to use a generic
1153 : * plan or a custom plan for the given parameters: the caller does not know
1154 : * which it will get.
1155 : *
1156 : * On return, the plan is valid and we have sufficient locks to begin
1157 : * execution.
1158 : *
1159 : * On return, the refcount of the plan has been incremented; a later
1160 : * ReleaseCachedPlan() call is expected. If "owner" is not NULL then
1161 : * the refcount has been reported to that ResourceOwner (note that this
1162 : * is only supported for "saved" CachedPlanSources).
1163 : *
1164 : * Note: if any replanning activity is required, the caller's memory context
1165 : * is used for that work.
1166 : */
1167 : CachedPlan *
1168 159590 : GetCachedPlan(CachedPlanSource *plansource, ParamListInfo boundParams,
1169 : ResourceOwner owner, QueryEnvironment *queryEnv)
1170 : {
1171 159590 : CachedPlan *plan = NULL;
1172 : List *qlist;
1173 : bool customplan;
1174 :
1175 : /* Assert caller is doing things in a sane order */
1176 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
1177 : Assert(plansource->is_complete);
1178 : /* This seems worth a real test, though */
1179 159590 : if (owner && !plansource->is_saved)
1180 0 : elog(ERROR, "cannot apply ResourceOwner to non-saved cached plan");
1181 :
1182 : /* Make sure the querytree list is valid and we have parse-time locks */
1183 159590 : qlist = RevalidateCachedQuery(plansource, queryEnv);
1184 :
1185 : /* Decide whether to use a custom plan */
1186 159552 : customplan = choose_custom_plan(plansource, boundParams);
1187 :
1188 159552 : if (!customplan)
1189 : {
1190 123172 : if (CheckCachedPlan(plansource))
1191 : {
1192 : /* We want a generic plan, and we already have a valid one */
1193 80014 : plan = plansource->gplan;
1194 : Assert(plan->magic == CACHEDPLAN_MAGIC);
1195 : }
1196 : else
1197 : {
1198 : /* Build a new generic plan */
1199 43158 : plan = BuildCachedPlan(plansource, qlist, NULL, queryEnv);
1200 : /* Just make real sure plansource->gplan is clear */
1201 43106 : ReleaseGenericPlan(plansource);
1202 : /* Link the new generic plan into the plansource */
1203 43106 : plansource->gplan = plan;
1204 43106 : plan->refcount++;
1205 : /* Immediately reparent into appropriate context */
1206 43106 : if (plansource->is_saved)
1207 : {
1208 : /* saved plans all live under CacheMemoryContext */
1209 32508 : MemoryContextSetParent(plan->context, CacheMemoryContext);
1210 32508 : plan->is_saved = true;
1211 : }
1212 : else
1213 : {
1214 : /* otherwise, it should be a sibling of the plansource */
1215 10598 : MemoryContextSetParent(plan->context,
1216 : MemoryContextGetParent(plansource->context));
1217 : }
1218 : /* Update generic_cost whenever we make a new generic plan */
1219 43106 : plansource->generic_cost = cached_plan_cost(plan, false);
1220 :
1221 : /*
1222 : * If, based on the now-known value of generic_cost, we'd not have
1223 : * chosen to use a generic plan, then forget it and make a custom
1224 : * plan. This is a bit of a wart but is necessary to avoid a
1225 : * glitch in behavior when the custom plans are consistently big
1226 : * winners; at some point we'll experiment with a generic plan and
1227 : * find it's a loser, but we don't want to actually execute that
1228 : * plan.
1229 : */
1230 43106 : customplan = choose_custom_plan(plansource, boundParams);
1231 :
1232 : /*
1233 : * If we choose to plan again, we need to re-copy the query_list,
1234 : * since the planner probably scribbled on it. We can force
1235 : * BuildCachedPlan to do that by passing NIL.
1236 : */
1237 43106 : qlist = NIL;
1238 : }
1239 : }
1240 :
1241 159500 : if (customplan)
1242 : {
1243 : /* Build a custom plan */
1244 36432 : plan = BuildCachedPlan(plansource, qlist, boundParams, queryEnv);
1245 : /* Accumulate total costs of custom plans */
1246 36316 : plansource->total_custom_cost += cached_plan_cost(plan, true);
1247 :
1248 36316 : plansource->num_custom_plans++;
1249 : }
1250 : else
1251 : {
1252 123068 : plansource->num_generic_plans++;
1253 : }
1254 :
1255 : Assert(plan != NULL);
1256 :
1257 : /* Flag the plan as in use by caller */
1258 159384 : if (owner)
1259 102380 : ResourceOwnerEnlarge(owner);
1260 159384 : plan->refcount++;
1261 159384 : if (owner)
1262 102380 : ResourceOwnerRememberPlanCacheRef(owner, plan);
1263 :
1264 : /*
1265 : * Saved plans should be under CacheMemoryContext so they will not go away
1266 : * until their reference count goes to zero. In the generic-plan cases we
1267 : * already took care of that, but for a custom plan, do it as soon as we
1268 : * have created a reference-counted link.
1269 : */
1270 159384 : if (customplan && plansource->is_saved)
1271 : {
1272 23892 : MemoryContextSetParent(plan->context, CacheMemoryContext);
1273 23892 : plan->is_saved = true;
1274 : }
1275 :
1276 159384 : return plan;
1277 : }
1278 :
1279 : /*
1280 : * ReleaseCachedPlan: release active use of a cached plan.
1281 : *
1282 : * This decrements the reference count, and frees the plan if the count
1283 : * has thereby gone to zero. If "owner" is not NULL, it is assumed that
1284 : * the reference count is managed by that ResourceOwner.
1285 : *
1286 : * Note: owner == NULL is used for releasing references that are in
1287 : * persistent data structures, such as the parent CachedPlanSource or a
1288 : * Portal. Transient references should be protected by a resource owner.
1289 : */
1290 : void
1291 247204 : ReleaseCachedPlan(CachedPlan *plan, ResourceOwner owner)
1292 : {
1293 : Assert(plan->magic == CACHEDPLAN_MAGIC);
1294 247204 : if (owner)
1295 : {
1296 : Assert(plan->is_saved);
1297 99752 : ResourceOwnerForgetPlanCacheRef(owner, plan);
1298 : }
1299 : Assert(plan->refcount > 0);
1300 247204 : plan->refcount--;
1301 247204 : if (plan->refcount == 0)
1302 : {
1303 : /* Mark it no longer valid */
1304 48378 : plan->magic = 0;
1305 :
1306 : /* One-shot plans do not own their context, so we can't free them */
1307 48378 : if (!plan->is_oneshot)
1308 36126 : MemoryContextDelete(plan->context);
1309 : }
1310 247204 : }
1311 :
1312 : /*
1313 : * CachedPlanAllowsSimpleValidityCheck: can we use CachedPlanIsSimplyValid?
1314 : *
1315 : * This function, together with CachedPlanIsSimplyValid, provides a fast path
1316 : * for revalidating "simple" generic plans. The core requirement to be simple
1317 : * is that the plan must not require taking any locks, which translates to
1318 : * not touching any tables; this happens to match up well with an important
1319 : * use-case in PL/pgSQL. This function tests whether that's true, along
1320 : * with checking some other corner cases that we'd rather not bother with
1321 : * handling in the fast path. (Note that it's still possible for such a plan
1322 : * to be invalidated, for example due to a change in a function that was
1323 : * inlined into the plan.)
1324 : *
1325 : * If the plan is simply valid, and "owner" is not NULL, record a refcount on
1326 : * the plan in that resowner before returning. It is caller's responsibility
1327 : * to be sure that a refcount is held on any plan that's being actively used.
1328 : *
1329 : * This must only be called on known-valid generic plans (eg, ones just
1330 : * returned by GetCachedPlan). If it returns true, the caller may re-use
1331 : * the cached plan as long as CachedPlanIsSimplyValid returns true; that
1332 : * check is much cheaper than the full revalidation done by GetCachedPlan.
1333 : * Nonetheless, no required checks are omitted.
1334 : */
1335 : bool
1336 26748 : CachedPlanAllowsSimpleValidityCheck(CachedPlanSource *plansource,
1337 : CachedPlan *plan, ResourceOwner owner)
1338 : {
1339 : ListCell *lc;
1340 :
1341 : /*
1342 : * Sanity-check that the caller gave us a validated generic plan. Notice
1343 : * that we *don't* assert plansource->is_valid as you might expect; that's
1344 : * because it's possible that that's already false when GetCachedPlan
1345 : * returns, e.g. because ResetPlanCache happened partway through. We
1346 : * should accept the plan as long as plan->is_valid is true, and expect to
1347 : * replan after the next CachedPlanIsSimplyValid call.
1348 : */
1349 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
1350 : Assert(plan->magic == CACHEDPLAN_MAGIC);
1351 : Assert(plan->is_valid);
1352 : Assert(plan == plansource->gplan);
1353 : Assert(plansource->search_path != NULL);
1354 : Assert(SearchPathMatchesCurrentEnvironment(plansource->search_path));
1355 :
1356 : /* We don't support oneshot plans here. */
1357 26748 : if (plansource->is_oneshot)
1358 0 : return false;
1359 : Assert(!plan->is_oneshot);
1360 :
1361 : /*
1362 : * If the plan is dependent on RLS considerations, or it's transient,
1363 : * reject. These things probably can't ever happen for table-free
1364 : * queries, but for safety's sake let's check.
1365 : */
1366 26748 : if (plansource->dependsOnRLS)
1367 0 : return false;
1368 26748 : if (plan->dependsOnRole)
1369 0 : return false;
1370 26748 : if (TransactionIdIsValid(plan->saved_xmin))
1371 0 : return false;
1372 :
1373 : /*
1374 : * Reject if AcquirePlannerLocks would have anything to do. This is
1375 : * simplistic, but there's no need to inquire any more carefully; indeed,
1376 : * for current callers it shouldn't even be possible to hit any of these
1377 : * checks.
1378 : */
1379 53496 : foreach(lc, plansource->query_list)
1380 : {
1381 26748 : Query *query = lfirst_node(Query, lc);
1382 :
1383 26748 : if (query->commandType == CMD_UTILITY)
1384 0 : return false;
1385 26748 : if (query->rtable || query->cteList || query->hasSubLinks)
1386 0 : return false;
1387 : }
1388 :
1389 : /*
1390 : * Reject if AcquireExecutorLocks would have anything to do. This is
1391 : * probably unnecessary given the previous check, but let's be safe.
1392 : */
1393 53496 : foreach(lc, plan->stmt_list)
1394 : {
1395 26748 : PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
1396 : ListCell *lc2;
1397 :
1398 26748 : if (plannedstmt->commandType == CMD_UTILITY)
1399 0 : return false;
1400 :
1401 : /*
1402 : * We have to grovel through the rtable because it's likely to contain
1403 : * an RTE_RESULT relation, rather than being totally empty.
1404 : */
1405 53496 : foreach(lc2, plannedstmt->rtable)
1406 : {
1407 26748 : RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc2);
1408 :
1409 26748 : if (rte->rtekind == RTE_RELATION)
1410 0 : return false;
1411 : }
1412 : }
1413 :
1414 : /*
1415 : * Okay, it's simple. Note that what we've primarily established here is
1416 : * that no locks need be taken before checking the plan's is_valid flag.
1417 : */
1418 :
1419 : /* Bump refcount if requested. */
1420 26748 : if (owner)
1421 : {
1422 26748 : ResourceOwnerEnlarge(owner);
1423 26748 : plan->refcount++;
1424 26748 : ResourceOwnerRememberPlanCacheRef(owner, plan);
1425 : }
1426 :
1427 26748 : return true;
1428 : }
1429 :
1430 : /*
1431 : * CachedPlanIsSimplyValid: quick check for plan still being valid
1432 : *
1433 : * This function must not be used unless CachedPlanAllowsSimpleValidityCheck
1434 : * previously said it was OK.
1435 : *
1436 : * If the plan is valid, and "owner" is not NULL, record a refcount on
1437 : * the plan in that resowner before returning. It is caller's responsibility
1438 : * to be sure that a refcount is held on any plan that's being actively used.
1439 : *
1440 : * The code here is unconditionally safe as long as the only use of this
1441 : * CachedPlanSource is in connection with the particular CachedPlan pointer
1442 : * that's passed in. If the plansource were being used for other purposes,
1443 : * it's possible that its generic plan could be invalidated and regenerated
1444 : * while the current caller wasn't looking, and then there could be a chance
1445 : * collision of address between this caller's now-stale plan pointer and the
1446 : * actual address of the new generic plan. For current uses, that scenario
1447 : * can't happen; but with a plansource shared across multiple uses, it'd be
1448 : * advisable to also save plan->generation and verify that that still matches.
1449 : */
1450 : bool
1451 263816 : CachedPlanIsSimplyValid(CachedPlanSource *plansource, CachedPlan *plan,
1452 : ResourceOwner owner)
1453 : {
1454 : /*
1455 : * Careful here: since the caller doesn't necessarily hold a refcount on
1456 : * the plan to start with, it's possible that "plan" is a dangling
1457 : * pointer. Don't dereference it until we've verified that it still
1458 : * matches the plansource's gplan (which is either valid or NULL).
1459 : */
1460 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
1461 :
1462 : /*
1463 : * Has cache invalidation fired on this plan? We can check this right
1464 : * away since there are no locks that we'd need to acquire first. Note
1465 : * that here we *do* check plansource->is_valid, so as to force plan
1466 : * rebuild if that's become false.
1467 : */
1468 263816 : if (!plansource->is_valid ||
1469 258834 : plan == NULL || plan != plansource->gplan ||
1470 258834 : !plan->is_valid)
1471 4994 : return false;
1472 :
1473 : Assert(plan->magic == CACHEDPLAN_MAGIC);
1474 :
1475 : /* Is the search_path still the same as when we made it? */
1476 : Assert(plansource->search_path != NULL);
1477 258822 : if (!SearchPathMatchesCurrentEnvironment(plansource->search_path))
1478 126 : return false;
1479 :
1480 : /* It's still good. Bump refcount if requested. */
1481 258696 : if (owner)
1482 : {
1483 49158 : ResourceOwnerEnlarge(owner);
1484 49158 : plan->refcount++;
1485 49158 : ResourceOwnerRememberPlanCacheRef(owner, plan);
1486 : }
1487 :
1488 258696 : return true;
1489 : }
1490 :
1491 : /*
1492 : * CachedPlanSetParentContext: move a CachedPlanSource to a new memory context
1493 : *
1494 : * This can only be applied to unsaved plans; once saved, a plan always
1495 : * lives underneath CacheMemoryContext.
1496 : */
1497 : void
1498 29744 : CachedPlanSetParentContext(CachedPlanSource *plansource,
1499 : MemoryContext newcontext)
1500 : {
1501 : /* Assert caller is doing things in a sane order */
1502 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
1503 : Assert(plansource->is_complete);
1504 :
1505 : /* These seem worth real tests, though */
1506 29744 : if (plansource->is_saved)
1507 0 : elog(ERROR, "cannot move a saved cached plan to another context");
1508 29744 : if (plansource->is_oneshot)
1509 0 : elog(ERROR, "cannot move a one-shot cached plan to another context");
1510 :
1511 : /* OK, let the caller keep the plan where he wishes */
1512 29744 : MemoryContextSetParent(plansource->context, newcontext);
1513 :
1514 : /*
1515 : * The query_context needs no special handling, since it's a child of
1516 : * plansource->context. But if there's a generic plan, it should be
1517 : * maintained as a sibling of plansource->context.
1518 : */
1519 29744 : if (plansource->gplan)
1520 : {
1521 : Assert(plansource->gplan->magic == CACHEDPLAN_MAGIC);
1522 0 : MemoryContextSetParent(plansource->gplan->context, newcontext);
1523 : }
1524 29744 : }
1525 :
1526 : /*
1527 : * CopyCachedPlan: make a copy of a CachedPlanSource
1528 : *
1529 : * This is a convenience routine that does the equivalent of
1530 : * CreateCachedPlan + CompleteCachedPlan, using the data stored in the
1531 : * input CachedPlanSource. The result is therefore "unsaved" (regardless
1532 : * of the state of the source), and we don't copy any generic plan either.
1533 : * The result will be currently valid, or not, the same as the source.
1534 : */
1535 : CachedPlanSource *
1536 0 : CopyCachedPlan(CachedPlanSource *plansource)
1537 : {
1538 : CachedPlanSource *newsource;
1539 : MemoryContext source_context;
1540 : MemoryContext querytree_context;
1541 : MemoryContext oldcxt;
1542 :
1543 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
1544 : Assert(plansource->is_complete);
1545 :
1546 : /*
1547 : * One-shot plans can't be copied, because we haven't taken care that
1548 : * parsing/planning didn't scribble on the raw parse tree or querytrees.
1549 : */
1550 0 : if (plansource->is_oneshot)
1551 0 : elog(ERROR, "cannot copy a one-shot cached plan");
1552 :
1553 0 : source_context = AllocSetContextCreate(CurrentMemoryContext,
1554 : "CachedPlanSource",
1555 : ALLOCSET_START_SMALL_SIZES);
1556 :
1557 0 : oldcxt = MemoryContextSwitchTo(source_context);
1558 :
1559 0 : newsource = (CachedPlanSource *) palloc0(sizeof(CachedPlanSource));
1560 0 : newsource->magic = CACHEDPLANSOURCE_MAGIC;
1561 0 : newsource->raw_parse_tree = copyObject(plansource->raw_parse_tree);
1562 0 : newsource->query_string = pstrdup(plansource->query_string);
1563 0 : MemoryContextSetIdentifier(source_context, newsource->query_string);
1564 0 : newsource->commandTag = plansource->commandTag;
1565 0 : if (plansource->num_params > 0)
1566 : {
1567 0 : newsource->param_types = (Oid *)
1568 0 : palloc(plansource->num_params * sizeof(Oid));
1569 0 : memcpy(newsource->param_types, plansource->param_types,
1570 0 : plansource->num_params * sizeof(Oid));
1571 : }
1572 : else
1573 0 : newsource->param_types = NULL;
1574 0 : newsource->num_params = plansource->num_params;
1575 0 : newsource->parserSetup = plansource->parserSetup;
1576 0 : newsource->parserSetupArg = plansource->parserSetupArg;
1577 0 : newsource->cursor_options = plansource->cursor_options;
1578 0 : newsource->fixed_result = plansource->fixed_result;
1579 0 : if (plansource->resultDesc)
1580 0 : newsource->resultDesc = CreateTupleDescCopy(plansource->resultDesc);
1581 : else
1582 0 : newsource->resultDesc = NULL;
1583 0 : newsource->context = source_context;
1584 :
1585 0 : querytree_context = AllocSetContextCreate(source_context,
1586 : "CachedPlanQuery",
1587 : ALLOCSET_START_SMALL_SIZES);
1588 0 : MemoryContextSwitchTo(querytree_context);
1589 0 : newsource->query_list = copyObject(plansource->query_list);
1590 0 : newsource->relationOids = copyObject(plansource->relationOids);
1591 0 : newsource->invalItems = copyObject(plansource->invalItems);
1592 0 : if (plansource->search_path)
1593 0 : newsource->search_path = CopySearchPathMatcher(plansource->search_path);
1594 0 : newsource->query_context = querytree_context;
1595 0 : newsource->rewriteRoleId = plansource->rewriteRoleId;
1596 0 : newsource->rewriteRowSecurity = plansource->rewriteRowSecurity;
1597 0 : newsource->dependsOnRLS = plansource->dependsOnRLS;
1598 :
1599 0 : newsource->gplan = NULL;
1600 :
1601 0 : newsource->is_oneshot = false;
1602 0 : newsource->is_complete = true;
1603 0 : newsource->is_saved = false;
1604 0 : newsource->is_valid = plansource->is_valid;
1605 0 : newsource->generation = plansource->generation;
1606 :
1607 : /* We may as well copy any acquired cost knowledge */
1608 0 : newsource->generic_cost = plansource->generic_cost;
1609 0 : newsource->total_custom_cost = plansource->total_custom_cost;
1610 0 : newsource->num_generic_plans = plansource->num_generic_plans;
1611 0 : newsource->num_custom_plans = plansource->num_custom_plans;
1612 :
1613 0 : MemoryContextSwitchTo(oldcxt);
1614 :
1615 0 : return newsource;
1616 : }
1617 :
1618 : /*
1619 : * CachedPlanIsValid: test whether the rewritten querytree within a
1620 : * CachedPlanSource is currently valid (that is, not marked as being in need
1621 : * of revalidation).
1622 : *
1623 : * This result is only trustworthy (ie, free from race conditions) if
1624 : * the caller has acquired locks on all the relations used in the plan.
1625 : */
1626 : bool
1627 3706 : CachedPlanIsValid(CachedPlanSource *plansource)
1628 : {
1629 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
1630 3706 : return plansource->is_valid;
1631 : }
1632 :
1633 : /*
1634 : * CachedPlanGetTargetList: return tlist, if any, describing plan's output
1635 : *
1636 : * The result is guaranteed up-to-date. However, it is local storage
1637 : * within the cached plan, and may disappear next time the plan is updated.
1638 : */
1639 : List *
1640 11266 : CachedPlanGetTargetList(CachedPlanSource *plansource,
1641 : QueryEnvironment *queryEnv)
1642 : {
1643 : Query *pstmt;
1644 :
1645 : /* Assert caller is doing things in a sane order */
1646 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
1647 : Assert(plansource->is_complete);
1648 :
1649 : /*
1650 : * No work needed if statement doesn't return tuples (we assume this
1651 : * feature cannot be changed by an invalidation)
1652 : */
1653 11266 : if (plansource->resultDesc == NULL)
1654 0 : return NIL;
1655 :
1656 : /* Make sure the querytree list is valid and we have parse-time locks */
1657 11266 : RevalidateCachedQuery(plansource, queryEnv);
1658 :
1659 : /* Get the primary statement and find out what it returns */
1660 11266 : pstmt = QueryListGetPrimaryStmt(plansource->query_list);
1661 :
1662 11266 : return FetchStatementTargetList((Node *) pstmt);
1663 : }
1664 :
1665 : /*
1666 : * GetCachedExpression: construct a CachedExpression for an expression.
1667 : *
1668 : * This performs the same transformations on the expression as
1669 : * expression_planner(), ie, convert an expression as emitted by parse
1670 : * analysis to be ready to pass to the executor.
1671 : *
1672 : * The result is stashed in a private, long-lived memory context.
1673 : * (Note that this might leak a good deal of memory in the caller's
1674 : * context before that.) The passed-in expr tree is not modified.
1675 : */
1676 : CachedExpression *
1677 336 : GetCachedExpression(Node *expr)
1678 : {
1679 : CachedExpression *cexpr;
1680 : List *relationOids;
1681 : List *invalItems;
1682 : MemoryContext cexpr_context;
1683 : MemoryContext oldcxt;
1684 :
1685 : /*
1686 : * Pass the expression through the planner, and collect dependencies.
1687 : * Everything built here is leaked in the caller's context; that's
1688 : * intentional to minimize the size of the permanent data structure.
1689 : */
1690 336 : expr = (Node *) expression_planner_with_deps((Expr *) expr,
1691 : &relationOids,
1692 : &invalItems);
1693 :
1694 : /*
1695 : * Make a private memory context, and copy what we need into that. To
1696 : * avoid leaking a long-lived context if we fail while copying data, we
1697 : * initially make the context under the caller's context.
1698 : */
1699 336 : cexpr_context = AllocSetContextCreate(CurrentMemoryContext,
1700 : "CachedExpression",
1701 : ALLOCSET_SMALL_SIZES);
1702 :
1703 336 : oldcxt = MemoryContextSwitchTo(cexpr_context);
1704 :
1705 336 : cexpr = (CachedExpression *) palloc(sizeof(CachedExpression));
1706 336 : cexpr->magic = CACHEDEXPR_MAGIC;
1707 336 : cexpr->expr = copyObject(expr);
1708 336 : cexpr->is_valid = true;
1709 336 : cexpr->relationOids = copyObject(relationOids);
1710 336 : cexpr->invalItems = copyObject(invalItems);
1711 336 : cexpr->context = cexpr_context;
1712 :
1713 336 : MemoryContextSwitchTo(oldcxt);
1714 :
1715 : /*
1716 : * Reparent the expr's memory context under CacheMemoryContext so that it
1717 : * will live indefinitely.
1718 : */
1719 336 : MemoryContextSetParent(cexpr_context, CacheMemoryContext);
1720 :
1721 : /*
1722 : * Add the entry to the global list of cached expressions.
1723 : */
1724 336 : dlist_push_tail(&cached_expression_list, &cexpr->node);
1725 :
1726 336 : return cexpr;
1727 : }
1728 :
1729 : /*
1730 : * FreeCachedExpression
1731 : * Delete a CachedExpression.
1732 : */
1733 : void
1734 28 : FreeCachedExpression(CachedExpression *cexpr)
1735 : {
1736 : /* Sanity check */
1737 : Assert(cexpr->magic == CACHEDEXPR_MAGIC);
1738 : /* Unlink from global list */
1739 28 : dlist_delete(&cexpr->node);
1740 : /* Free all storage associated with CachedExpression */
1741 28 : MemoryContextDelete(cexpr->context);
1742 28 : }
1743 :
1744 : /*
1745 : * QueryListGetPrimaryStmt
1746 : * Get the "primary" stmt within a list, ie, the one marked canSetTag.
1747 : *
1748 : * Returns NULL if no such stmt. If multiple queries within the list are
1749 : * marked canSetTag, returns the first one. Neither of these cases should
1750 : * occur in present usages of this function.
1751 : */
1752 : static Query *
1753 11478 : QueryListGetPrimaryStmt(List *stmts)
1754 : {
1755 : ListCell *lc;
1756 :
1757 11478 : foreach(lc, stmts)
1758 : {
1759 11478 : Query *stmt = lfirst_node(Query, lc);
1760 :
1761 11478 : if (stmt->canSetTag)
1762 11478 : return stmt;
1763 : }
1764 0 : return NULL;
1765 : }
1766 :
1767 : /*
1768 : * AcquireExecutorLocks: acquire locks needed for execution of a cached plan;
1769 : * or release them if acquire is false.
1770 : */
1771 : static void
1772 80014 : AcquireExecutorLocks(List *stmt_list, bool acquire)
1773 : {
1774 : ListCell *lc1;
1775 :
1776 160028 : foreach(lc1, stmt_list)
1777 : {
1778 80014 : PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc1);
1779 : ListCell *lc2;
1780 :
1781 80014 : if (plannedstmt->commandType == CMD_UTILITY)
1782 : {
1783 : /*
1784 : * Ignore utility statements, except those (such as EXPLAIN) that
1785 : * contain a parsed-but-not-planned query. Note: it's okay to use
1786 : * ScanQueryForLocks, even though the query hasn't been through
1787 : * rule rewriting, because rewriting doesn't change the query
1788 : * representation.
1789 : */
1790 11472 : Query *query = UtilityContainsQuery(plannedstmt->utilityStmt);
1791 :
1792 11472 : if (query)
1793 6 : ScanQueryForLocks(query, acquire);
1794 11472 : continue;
1795 : }
1796 :
1797 179734 : foreach(lc2, plannedstmt->rtable)
1798 : {
1799 111192 : RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc2);
1800 :
1801 111192 : if (!(rte->rtekind == RTE_RELATION ||
1802 63810 : (rte->rtekind == RTE_SUBQUERY && OidIsValid(rte->relid))))
1803 59996 : continue;
1804 :
1805 : /*
1806 : * Acquire the appropriate type of lock on each relation OID. Note
1807 : * that we don't actually try to open the rel, and hence will not
1808 : * fail if it's been dropped entirely --- we'll just transiently
1809 : * acquire a non-conflicting lock.
1810 : */
1811 51196 : if (acquire)
1812 51196 : LockRelationOid(rte->relid, rte->rellockmode);
1813 : else
1814 0 : UnlockRelationOid(rte->relid, rte->rellockmode);
1815 : }
1816 : }
1817 80014 : }
1818 :
1819 : /*
1820 : * AcquirePlannerLocks: acquire locks needed for planning of a querytree list;
1821 : * or release them if acquire is false.
1822 : *
1823 : * Note that we don't actually try to open the relations, and hence will not
1824 : * fail if one has been dropped entirely --- we'll just transiently acquire
1825 : * a non-conflicting lock.
1826 : */
1827 : static void
1828 139882 : AcquirePlannerLocks(List *stmt_list, bool acquire)
1829 : {
1830 : ListCell *lc;
1831 :
1832 279764 : foreach(lc, stmt_list)
1833 : {
1834 139882 : Query *query = lfirst_node(Query, lc);
1835 :
1836 139882 : if (query->commandType == CMD_UTILITY)
1837 : {
1838 : /* Ignore utility statements, unless they contain a Query */
1839 9648 : query = UtilityContainsQuery(query->utilityStmt);
1840 9648 : if (query)
1841 9514 : ScanQueryForLocks(query, acquire);
1842 9648 : continue;
1843 : }
1844 :
1845 130234 : ScanQueryForLocks(query, acquire);
1846 : }
1847 139882 : }
1848 :
1849 : /*
1850 : * ScanQueryForLocks: recursively scan one Query for AcquirePlannerLocks.
1851 : */
1852 : static void
1853 160686 : ScanQueryForLocks(Query *parsetree, bool acquire)
1854 : {
1855 : ListCell *lc;
1856 :
1857 : /* Shouldn't get called on utility commands */
1858 : Assert(parsetree->commandType != CMD_UTILITY);
1859 :
1860 : /*
1861 : * First, process RTEs of the current query level.
1862 : */
1863 307492 : foreach(lc, parsetree->rtable)
1864 : {
1865 146806 : RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
1866 :
1867 146806 : switch (rte->rtekind)
1868 : {
1869 102994 : case RTE_RELATION:
1870 : /* Acquire or release the appropriate type of lock */
1871 102994 : if (acquire)
1872 102978 : LockRelationOid(rte->relid, rte->rellockmode);
1873 : else
1874 16 : UnlockRelationOid(rte->relid, rte->rellockmode);
1875 102994 : break;
1876 :
1877 17522 : case RTE_SUBQUERY:
1878 : /* If this was a view, must lock/unlock the view */
1879 17522 : if (OidIsValid(rte->relid))
1880 : {
1881 3956 : if (acquire)
1882 3956 : LockRelationOid(rte->relid, rte->rellockmode);
1883 : else
1884 0 : UnlockRelationOid(rte->relid, rte->rellockmode);
1885 : }
1886 : /* Recurse into subquery-in-FROM */
1887 17522 : ScanQueryForLocks(rte->subquery, acquire);
1888 17522 : break;
1889 :
1890 26290 : default:
1891 : /* ignore other types of RTEs */
1892 26290 : break;
1893 : }
1894 : }
1895 :
1896 : /* Recurse into subquery-in-WITH */
1897 160776 : foreach(lc, parsetree->cteList)
1898 : {
1899 90 : CommonTableExpr *cte = lfirst_node(CommonTableExpr, lc);
1900 :
1901 90 : ScanQueryForLocks(castNode(Query, cte->ctequery), acquire);
1902 : }
1903 :
1904 : /*
1905 : * Recurse into sublink subqueries, too. But we already did the ones in
1906 : * the rtable and cteList.
1907 : */
1908 160686 : if (parsetree->hasSubLinks)
1909 : {
1910 3298 : query_tree_walker(parsetree, ScanQueryWalker,
1911 : (void *) &acquire,
1912 : QTW_IGNORE_RC_SUBQUERIES);
1913 : }
1914 160686 : }
1915 :
1916 : /*
1917 : * Walker to find sublink subqueries for ScanQueryForLocks
1918 : */
1919 : static bool
1920 83980 : ScanQueryWalker(Node *node, bool *acquire)
1921 : {
1922 83980 : if (node == NULL)
1923 40160 : return false;
1924 43820 : if (IsA(node, SubLink))
1925 : {
1926 3320 : SubLink *sub = (SubLink *) node;
1927 :
1928 : /* Do what we came for */
1929 3320 : ScanQueryForLocks(castNode(Query, sub->subselect), *acquire);
1930 : /* Fall through to process lefthand args of SubLink */
1931 : }
1932 :
1933 : /*
1934 : * Do NOT recurse into Query nodes, because ScanQueryForLocks already
1935 : * processed subselects of subselects for us.
1936 : */
1937 43820 : return expression_tree_walker(node, ScanQueryWalker,
1938 : (void *) acquire);
1939 : }
1940 :
1941 : /*
1942 : * PlanCacheComputeResultDesc: given a list of analyzed-and-rewritten Queries,
1943 : * determine the result tupledesc it will produce. Returns NULL if the
1944 : * execution will not return tuples.
1945 : *
1946 : * Note: the result is created or copied into current memory context.
1947 : */
1948 : static TupleDesc
1949 69410 : PlanCacheComputeResultDesc(List *stmt_list)
1950 : {
1951 : Query *query;
1952 :
1953 69410 : switch (ChoosePortalStrategy(stmt_list))
1954 : {
1955 49952 : case PORTAL_ONE_SELECT:
1956 : case PORTAL_ONE_MOD_WITH:
1957 49952 : query = linitial_node(Query, stmt_list);
1958 49952 : return ExecCleanTypeFromTL(query->targetList);
1959 :
1960 212 : case PORTAL_ONE_RETURNING:
1961 212 : query = QueryListGetPrimaryStmt(stmt_list);
1962 : Assert(query->returningList);
1963 212 : return ExecCleanTypeFromTL(query->returningList);
1964 :
1965 8118 : case PORTAL_UTIL_SELECT:
1966 8118 : query = linitial_node(Query, stmt_list);
1967 : Assert(query->utilityStmt);
1968 8118 : return UtilityTupleDescriptor(query->utilityStmt);
1969 :
1970 11128 : case PORTAL_MULTI_QUERY:
1971 : /* will not return tuples */
1972 11128 : break;
1973 : }
1974 11128 : return NULL;
1975 : }
1976 :
1977 : /*
1978 : * PlanCacheRelCallback
1979 : * Relcache inval callback function
1980 : *
1981 : * Invalidate all plans mentioning the given rel, or all plans mentioning
1982 : * any rel at all if relid == InvalidOid.
1983 : */
1984 : static void
1985 2224836 : PlanCacheRelCallback(Datum arg, Oid relid)
1986 : {
1987 : dlist_iter iter;
1988 :
1989 46972456 : dlist_foreach(iter, &saved_plan_list)
1990 : {
1991 44747620 : CachedPlanSource *plansource = dlist_container(CachedPlanSource,
1992 : node, iter.cur);
1993 :
1994 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
1995 :
1996 : /* No work if it's already invalidated */
1997 44747620 : if (!plansource->is_valid)
1998 27817552 : continue;
1999 :
2000 : /* Never invalidate if parse/plan would be a no-op anyway */
2001 16930068 : if (!StmtPlanRequiresRevalidation(plansource))
2002 148894 : continue;
2003 :
2004 : /*
2005 : * Check the dependency list for the rewritten querytree.
2006 : */
2007 33562348 : if ((relid == InvalidOid) ? plansource->relationOids != NIL :
2008 16781174 : list_member_oid(plansource->relationOids, relid))
2009 : {
2010 : /* Invalidate the querytree and generic plan */
2011 3434 : plansource->is_valid = false;
2012 3434 : if (plansource->gplan)
2013 960 : plansource->gplan->is_valid = false;
2014 : }
2015 :
2016 : /*
2017 : * The generic plan, if any, could have more dependencies than the
2018 : * querytree does, so we have to check it too.
2019 : */
2020 16781174 : if (plansource->gplan && plansource->gplan->is_valid)
2021 : {
2022 : ListCell *lc;
2023 :
2024 32095908 : foreach(lc, plansource->gplan->stmt_list)
2025 : {
2026 16047988 : PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
2027 :
2028 16047988 : if (plannedstmt->commandType == CMD_UTILITY)
2029 2344 : continue; /* Ignore utility statements */
2030 32091288 : if ((relid == InvalidOid) ? plannedstmt->relationOids != NIL :
2031 16045644 : list_member_oid(plannedstmt->relationOids, relid))
2032 : {
2033 : /* Invalidate the generic plan only */
2034 68 : plansource->gplan->is_valid = false;
2035 68 : break; /* out of stmt_list scan */
2036 : }
2037 : }
2038 : }
2039 : }
2040 :
2041 : /* Likewise check cached expressions */
2042 2505678 : dlist_foreach(iter, &cached_expression_list)
2043 : {
2044 280842 : CachedExpression *cexpr = dlist_container(CachedExpression,
2045 : node, iter.cur);
2046 :
2047 : Assert(cexpr->magic == CACHEDEXPR_MAGIC);
2048 :
2049 : /* No work if it's already invalidated */
2050 280842 : if (!cexpr->is_valid)
2051 103420 : continue;
2052 :
2053 354844 : if ((relid == InvalidOid) ? cexpr->relationOids != NIL :
2054 177422 : list_member_oid(cexpr->relationOids, relid))
2055 : {
2056 0 : cexpr->is_valid = false;
2057 : }
2058 : }
2059 2224836 : }
2060 :
2061 : /*
2062 : * PlanCacheObjectCallback
2063 : * Syscache inval callback function for PROCOID and TYPEOID caches
2064 : *
2065 : * Invalidate all plans mentioning the object with the specified hash value,
2066 : * or all plans mentioning any member of this cache if hashvalue == 0.
2067 : */
2068 : static void
2069 900398 : PlanCacheObjectCallback(Datum arg, int cacheid, uint32 hashvalue)
2070 : {
2071 : dlist_iter iter;
2072 :
2073 19206360 : dlist_foreach(iter, &saved_plan_list)
2074 : {
2075 18305962 : CachedPlanSource *plansource = dlist_container(CachedPlanSource,
2076 : node, iter.cur);
2077 : ListCell *lc;
2078 :
2079 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
2080 :
2081 : /* No work if it's already invalidated */
2082 18305962 : if (!plansource->is_valid)
2083 10851054 : continue;
2084 :
2085 : /* Never invalidate if parse/plan would be a no-op anyway */
2086 7454908 : if (!StmtPlanRequiresRevalidation(plansource))
2087 68822 : continue;
2088 :
2089 : /*
2090 : * Check the dependency list for the rewritten querytree.
2091 : */
2092 7524714 : foreach(lc, plansource->invalItems)
2093 : {
2094 138740 : PlanInvalItem *item = (PlanInvalItem *) lfirst(lc);
2095 :
2096 138740 : if (item->cacheId != cacheid)
2097 91594 : continue;
2098 47146 : if (hashvalue == 0 ||
2099 47146 : item->hashValue == hashvalue)
2100 : {
2101 : /* Invalidate the querytree and generic plan */
2102 112 : plansource->is_valid = false;
2103 112 : if (plansource->gplan)
2104 100 : plansource->gplan->is_valid = false;
2105 112 : break;
2106 : }
2107 : }
2108 :
2109 : /*
2110 : * The generic plan, if any, could have more dependencies than the
2111 : * querytree does, so we have to check it too.
2112 : */
2113 7386086 : if (plansource->gplan && plansource->gplan->is_valid)
2114 : {
2115 14010828 : foreach(lc, plansource->gplan->stmt_list)
2116 : {
2117 7005426 : PlannedStmt *plannedstmt = lfirst_node(PlannedStmt, lc);
2118 : ListCell *lc3;
2119 :
2120 7005426 : if (plannedstmt->commandType == CMD_UTILITY)
2121 1206 : continue; /* Ignore utility statements */
2122 7137330 : foreach(lc3, plannedstmt->invalItems)
2123 : {
2124 133134 : PlanInvalItem *item = (PlanInvalItem *) lfirst(lc3);
2125 :
2126 133134 : if (item->cacheId != cacheid)
2127 86884 : continue;
2128 46250 : if (hashvalue == 0 ||
2129 46250 : item->hashValue == hashvalue)
2130 : {
2131 : /* Invalidate the generic plan only */
2132 24 : plansource->gplan->is_valid = false;
2133 24 : break; /* out of invalItems scan */
2134 : }
2135 : }
2136 7004220 : if (!plansource->gplan->is_valid)
2137 24 : break; /* out of stmt_list scan */
2138 : }
2139 : }
2140 : }
2141 :
2142 : /* Likewise check cached expressions */
2143 1038642 : dlist_foreach(iter, &cached_expression_list)
2144 : {
2145 138244 : CachedExpression *cexpr = dlist_container(CachedExpression,
2146 : node, iter.cur);
2147 : ListCell *lc;
2148 :
2149 : Assert(cexpr->magic == CACHEDEXPR_MAGIC);
2150 :
2151 : /* No work if it's already invalidated */
2152 138244 : if (!cexpr->is_valid)
2153 41242 : continue;
2154 :
2155 97032 : foreach(lc, cexpr->invalItems)
2156 : {
2157 36 : PlanInvalItem *item = (PlanInvalItem *) lfirst(lc);
2158 :
2159 36 : if (item->cacheId != cacheid)
2160 16 : continue;
2161 20 : if (hashvalue == 0 ||
2162 20 : item->hashValue == hashvalue)
2163 : {
2164 6 : cexpr->is_valid = false;
2165 6 : break;
2166 : }
2167 : }
2168 : }
2169 900398 : }
2170 :
2171 : /*
2172 : * PlanCacheSysCallback
2173 : * Syscache inval callback function for other caches
2174 : *
2175 : * Just invalidate everything...
2176 : */
2177 : static void
2178 54570 : PlanCacheSysCallback(Datum arg, int cacheid, uint32 hashvalue)
2179 : {
2180 54570 : ResetPlanCache();
2181 54570 : }
2182 :
2183 : /*
2184 : * ResetPlanCache: invalidate all cached plans.
2185 : */
2186 : void
2187 55350 : ResetPlanCache(void)
2188 : {
2189 : dlist_iter iter;
2190 :
2191 287248 : dlist_foreach(iter, &saved_plan_list)
2192 : {
2193 231898 : CachedPlanSource *plansource = dlist_container(CachedPlanSource,
2194 : node, iter.cur);
2195 :
2196 : Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC);
2197 :
2198 : /* No work if it's already invalidated */
2199 231898 : if (!plansource->is_valid)
2200 212904 : continue;
2201 :
2202 : /*
2203 : * We *must not* mark transaction control statements as invalid,
2204 : * particularly not ROLLBACK, because they may need to be executed in
2205 : * aborted transactions when we can't revalidate them (cf bug #5269).
2206 : * In general there's no point in invalidating statements for which a
2207 : * new parse analysis/rewrite/plan cycle would certainly give the same
2208 : * results.
2209 : */
2210 18994 : if (!StmtPlanRequiresRevalidation(plansource))
2211 5820 : continue;
2212 :
2213 13174 : plansource->is_valid = false;
2214 13174 : if (plansource->gplan)
2215 12174 : plansource->gplan->is_valid = false;
2216 : }
2217 :
2218 : /* Likewise invalidate cached expressions */
2219 56304 : dlist_foreach(iter, &cached_expression_list)
2220 : {
2221 954 : CachedExpression *cexpr = dlist_container(CachedExpression,
2222 : node, iter.cur);
2223 :
2224 : Assert(cexpr->magic == CACHEDEXPR_MAGIC);
2225 :
2226 954 : cexpr->is_valid = false;
2227 : }
2228 55350 : }
2229 :
2230 : /*
2231 : * Release all CachedPlans remembered by 'owner'
2232 : */
2233 : void
2234 15442 : ReleaseAllPlanCacheRefsInOwner(ResourceOwner owner)
2235 : {
2236 15442 : ResourceOwnerReleaseAllOfKind(owner, &planref_resowner_desc);
2237 15442 : }
2238 :
2239 : /* ResourceOwner callbacks */
2240 :
2241 : static void
2242 78534 : ResOwnerReleaseCachedPlan(Datum res)
2243 : {
2244 78534 : ReleaseCachedPlan((CachedPlan *) DatumGetPointer(res), NULL);
2245 78534 : }
|
