src/backend/utils/cache/plancache.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * plancache.c
   4  *        Plan cache management.
   5  *
   6  * We can store a cached plan in either fully-planned format, or just
   7  * parsed-and-rewritten if the caller wishes to postpone planning until
   8  * actual parameter values are available.  CachedPlanSource has the same
   9  * contents either way, but CachedPlan contains a list of PlannedStmts
  10  * and bare utility statements in the first case, or a list of Query nodes
  11  * in the second case.
  12  *
  13  * The plan cache manager itself is principally responsible for tracking
  14  * whether cached plans should be invalidated because of schema changes in
  15  * the objects they depend on.  When (and if) the next demand for a cached
  16  * plan occurs, the query will be replanned.  Note that this could result
  17  * in an error, for example if a column referenced by the query is no
  18  * longer present.      The creator of a cached plan can specify whether it
  19  * is allowable for the query to change output tupdesc on replan (this
  20  * could happen with "SELECT *" for example) --- if so, it's up to the
  21  * caller to notice changes and cope with them.
  22  *
  23  * Currently, we track exactly the dependencies of plans on relations and
  24  * user-defined functions.      On relcache invalidation events or pg_proc
  25  * syscache invalidation events, we invalidate just those plans that depend
  26  * on the particular object being modified.  (Note: this scheme assumes
  27  * that any table modification that requires replanning will generate a
  28  * relcache inval event.)  We also watch for inval events on certain other
  29  * system catalogs, such as pg_namespace; but for them, our response is
  30  * just to invalidate all plans.  We expect updates on those catalogs to
  31  * be infrequent enough that more-detailed tracking is not worth the effort.
  32  *
  33  *
  34  * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
  35  * Portions Copyright (c) 1994, Regents of the University of California
  36  *
  37  * IDENTIFICATION
  38  *        $PostgreSQL$
  39  *
  40  *-------------------------------------------------------------------------
  41  */
  42 #include "postgres.h"
  43
  44 #include "utils/plancache.h"
  45 #include "access/transam.h"
  46 #include "catalog/namespace.h"
  47 #include "executor/executor.h"
  48 #include "nodes/nodeFuncs.h"
  49 #include "optimizer/planmain.h"
  50 #include "storage/lmgr.h"
  51 #include "tcop/pquery.h"
  52 #include "tcop/tcopprot.h"
  53 #include "tcop/utility.h"
  54 #include "utils/inval.h"
  55 #include "utils/memutils.h"
  56 #include "utils/resowner.h"
  57 #include "utils/snapmgr.h"
  58 #include "utils/syscache.h"
  59
  60
  61 static List *cached_plans_list = NIL;
  62
  63 static void StoreCachedPlan(CachedPlanSource *plansource, List *stmt_list,
  64                                 MemoryContext plan_context);
  65 static void AcquireExecutorLocks(List *stmt_list, bool acquire);
  66 static void AcquirePlannerLocks(List *stmt_list, bool acquire);
  67 static void ScanQueryForLocks(Query *parsetree, bool acquire);
  68 static bool ScanQueryWalker(Node *node, bool *acquire);
  69 static bool rowmark_member(List *rowMarks, int rt_index);
  70 static bool plan_list_is_transient(List *stmt_list);
  71 static void PlanCacheRelCallback(Datum arg, Oid relid);
  72 static void PlanCacheFuncCallback(Datum arg, int cacheid, ItemPointer tuplePtr);
  73 static void PlanCacheSysCallback(Datum arg, int cacheid, ItemPointer tuplePtr);
  74
  75
  76 /*
  77  * InitPlanCache: initialize module during InitPostgres.
  78  *
  79  * All we need to do is hook into inval.c's callback lists.
  80  */
  81 void
  82 InitPlanCache(void)
  83 {
  84         CacheRegisterRelcacheCallback(PlanCacheRelCallback, (Datum) 0);
  85         CacheRegisterSyscacheCallback(PROCOID, PlanCacheFuncCallback, (Datum) 0);
  86         CacheRegisterSyscacheCallback(NAMESPACEOID, PlanCacheSysCallback, (Datum) 0);
  87         CacheRegisterSyscacheCallback(OPEROID, PlanCacheSysCallback, (Datum) 0);
  88         CacheRegisterSyscacheCallback(AMOPOPID, PlanCacheSysCallback, (Datum) 0);
  89 }
  90
  91 /*
  92  * CreateCachedPlan: initially create a plan cache entry.
  93  *
  94  * The caller must already have successfully parsed/planned the query;
  95  * about all that we do here is copy it into permanent storage.
  96  *
  97  * raw_parse_tree: output of raw_parser()
  98  * query_string: original query text (as of PG 8.4, must not be NULL)
  99  * commandTag: compile-time-constant tag for query, or NULL if empty query
 100  * param_types: array of parameter type OIDs, or NULL if none
 101  * num_params: number of parameters
 102  * cursor_options: options bitmask that was/will be passed to planner
 103  * stmt_list: list of PlannedStmts/utility stmts, or list of Query trees
 104  * fully_planned: are we caching planner or rewriter output?
 105  * fixed_result: TRUE to disallow changes in result tupdesc
 106  */
 107 CachedPlanSource *
 108 CreateCachedPlan(Node *raw_parse_tree,
 109                                  const char *query_string,
 110                                  const char *commandTag,
 111                                  Oid *param_types,
 112                                  int num_params,
 113                                  int cursor_options,
 114                                  List *stmt_list,
 115                                  bool fully_planned,
 116                                  bool fixed_result)
 117 {
 118         CachedPlanSource *plansource;
 119         OverrideSearchPath *search_path;
 120         MemoryContext source_context;
 121         MemoryContext oldcxt;
 122
 123         Assert(query_string != NULL);           /* required as of 8.4 */
 124
 125         /*
 126          * Make a dedicated memory context for the CachedPlanSource and its
 127          * subsidiary data.  We expect it can be pretty small.
 128          */
 129         source_context = AllocSetContextCreate(CacheMemoryContext,
 130                                                                                    "CachedPlanSource",
 131                                                                                    ALLOCSET_SMALL_MINSIZE,
 132                                                                                    ALLOCSET_SMALL_INITSIZE,
 133                                                                                    ALLOCSET_SMALL_MAXSIZE);
 134
 135         /*
 136          * Fetch current search_path into new context, but do any recalculation
 137          * work required in caller's context.
 138          */
 139         search_path = GetOverrideSearchPath(source_context);
 140
 141         /*
 142          * Create and fill the CachedPlanSource struct within the new context.
 143          */
 144         oldcxt = MemoryContextSwitchTo(source_context);
 145         plansource = (CachedPlanSource *) palloc(sizeof(CachedPlanSource));
 146         plansource->raw_parse_tree = copyObject(raw_parse_tree);
 147         plansource->query_string = pstrdup(query_string);
 148         plansource->commandTag = commandTag;            /* no copying needed */
 149         if (num_params > 0)
 150         {
 151                 plansource->param_types = (Oid *) palloc(num_params * sizeof(Oid));
 152                 memcpy(plansource->param_types, param_types, num_params * sizeof(Oid));
 153         }
 154         else
 155                 plansource->param_types = NULL;
 156         plansource->num_params = num_params;
 157         plansource->cursor_options = cursor_options;
 158         plansource->fully_planned = fully_planned;
 159         plansource->fixed_result = fixed_result;
 160         plansource->search_path = search_path;
 161         plansource->generation = 0; /* StoreCachedPlan will increment */
 162         plansource->resultDesc = PlanCacheComputeResultDesc(stmt_list);
 163         plansource->plan = NULL;
 164         plansource->context = source_context;
 165         plansource->orig_plan = NULL;
 166
 167         /*
 168          * Copy the current output plans into the plancache entry.
 169          */
 170         StoreCachedPlan(plansource, stmt_list, NULL);
 171
 172         /*
 173          * Now we can add the entry to the list of cached plans.  The List nodes
 174          * live in CacheMemoryContext.
 175          */
 176         MemoryContextSwitchTo(CacheMemoryContext);
 177
 178         cached_plans_list = lappend(cached_plans_list, plansource);
 179
 180         MemoryContextSwitchTo(oldcxt);
 181
 182         return plansource;
 183 }
 184
 185 /*
 186  * FastCreateCachedPlan: create a plan cache entry with minimal data copying.
 187  *
 188  * For plans that aren't expected to live very long, the copying overhead of
 189  * CreateCachedPlan is annoying.  We provide this variant entry point in which
 190  * the caller has already placed all the data in a suitable memory context.
 191  * The source data and completed plan are in the same context, since this
 192  * avoids extra copy steps during plan construction.  If the query ever does
 193  * need replanning, we'll generate a separate new CachedPlan at that time, but
 194  * the CachedPlanSource and the initial CachedPlan share the caller-provided
 195  * context and go away together when neither is needed any longer.      (Because
 196  * the parser and planner generate extra cruft in addition to their real
 197  * output, this approach means that the context probably contains a bunch of
 198  * useless junk as well as the useful trees.  Hence, this method is a
 199  * space-for-time tradeoff, which is worth making for plans expected to be
 200  * short-lived.)
 201  *
 202  * raw_parse_tree, query_string, param_types, and stmt_list must reside in the
 203  * given context, which must have adequate lifespan (recommendation: make it a
 204  * child of CacheMemoryContext).  Otherwise the API is the same as
 205  * CreateCachedPlan.
 206  */
 207 CachedPlanSource *
 208 FastCreateCachedPlan(Node *raw_parse_tree,
 209                                          char *query_string,
 210                                          const char *commandTag,
 211                                          Oid *param_types,
 212                                          int num_params,
 213                                          int cursor_options,
 214                                          List *stmt_list,
 215                                          bool fully_planned,
 216                                          bool fixed_result,
 217                                          MemoryContext context)
 218 {
 219         CachedPlanSource *plansource;
 220         OverrideSearchPath *search_path;
 221         MemoryContext oldcxt;
 222
 223         Assert(query_string != NULL);           /* required as of 8.4 */
 224
 225         /*
 226          * Fetch current search_path into given context, but do any recalculation
 227          * work required in caller's context.
 228          */
 229         search_path = GetOverrideSearchPath(context);
 230
 231         /*
 232          * Create and fill the CachedPlanSource struct within the given context.
 233          */
 234         oldcxt = MemoryContextSwitchTo(context);
 235         plansource = (CachedPlanSource *) palloc(sizeof(CachedPlanSource));
 236         plansource->raw_parse_tree = raw_parse_tree;
 237         plansource->query_string = query_string;
 238         plansource->commandTag = commandTag;            /* no copying needed */
 239         plansource->param_types = param_types;
 240         plansource->num_params = num_params;
 241         plansource->cursor_options = cursor_options;
 242         plansource->fully_planned = fully_planned;
 243         plansource->fixed_result = fixed_result;
 244         plansource->search_path = search_path;
 245         plansource->generation = 0; /* StoreCachedPlan will increment */
 246         plansource->resultDesc = PlanCacheComputeResultDesc(stmt_list);
 247         plansource->plan = NULL;
 248         plansource->context = context;
 249         plansource->orig_plan = NULL;
 250
 251         /*
 252          * Store the current output plans into the plancache entry.
 253          */
 254         StoreCachedPlan(plansource, stmt_list, context);
 255
 256         /*
 257          * Since the context is owned by the CachedPlan, advance its refcount.
 258          */
 259         plansource->orig_plan = plansource->plan;
 260         plansource->orig_plan->refcount++;
 261
 262         /*
 263          * Now we can add the entry to the list of cached plans.  The List nodes
 264          * live in CacheMemoryContext.
 265          */
 266         MemoryContextSwitchTo(CacheMemoryContext);
 267
 268         cached_plans_list = lappend(cached_plans_list, plansource);
 269
 270         MemoryContextSwitchTo(oldcxt);
 271
 272         return plansource;
 273 }
 274
 275 /*
 276  * StoreCachedPlan: store a built or rebuilt plan into a plancache entry.
 277  *
 278  * Common subroutine for CreateCachedPlan and RevalidateCachedPlan.
 279  */
 280 static void
 281 StoreCachedPlan(CachedPlanSource *plansource,
 282                                 List *stmt_list,
 283                                 MemoryContext plan_context)
 284 {
 285         CachedPlan *plan;
 286         MemoryContext oldcxt;
 287
 288         if (plan_context == NULL)
 289         {
 290                 /*
 291                  * Make a dedicated memory context for the CachedPlan and its
 292                  * subsidiary data.  It's probably not going to be large, but just in
 293                  * case, use the default maxsize parameter.
 294                  */
 295                 plan_context = AllocSetContextCreate(CacheMemoryContext,
 296                                                                                          "CachedPlan",
 297                                                                                          ALLOCSET_SMALL_MINSIZE,
 298                                                                                          ALLOCSET_SMALL_INITSIZE,
 299                                                                                          ALLOCSET_DEFAULT_MAXSIZE);
 300
 301                 /*
 302                  * Copy supplied data into the new context.
 303                  */
 304                 oldcxt = MemoryContextSwitchTo(plan_context);
 305
 306                 stmt_list = (List *) copyObject(stmt_list);
 307         }
 308         else
 309         {
 310                 /* Assume subsidiary data is in the given context */
 311                 oldcxt = MemoryContextSwitchTo(plan_context);
 312         }
 313
 314         /*
 315          * Create and fill the CachedPlan struct within the new context.
 316          */
 317         plan = (CachedPlan *) palloc(sizeof(CachedPlan));
 318         plan->stmt_list = stmt_list;
 319         plan->fully_planned = plansource->fully_planned;
 320         plan->dead = false;
 321         if (plansource->fully_planned && plan_list_is_transient(stmt_list))
 322         {
 323                 Assert(TransactionIdIsNormal(TransactionXmin));
 324                 plan->saved_xmin = TransactionXmin;
 325         }
 326         else
 327                 plan->saved_xmin = InvalidTransactionId;
 328         plan->refcount = 1;                     /* for the parent's link */
 329         plan->generation = ++(plansource->generation);
 330         plan->context = plan_context;
 331         if (plansource->fully_planned)
 332         {
 333                 /* Planner already extracted dependencies, we don't have to */
 334                 plan->relationOids = plan->invalItems = NIL;
 335         }
 336         else
 337         {
 338                 /* Use the planner machinery to extract dependencies */
 339                 extract_query_dependencies(stmt_list,
 340                                                                    &plan->relationOids,
 341                                                                    &plan->invalItems);
 342         }
 343
 344         Assert(plansource->plan == NULL);
 345         plansource->plan = plan;
 346
 347         MemoryContextSwitchTo(oldcxt);
 348 }
 349
 350 /*
 351  * DropCachedPlan: destroy a cached plan.
 352  *
 353  * Actually this only destroys the CachedPlanSource: the referenced CachedPlan
 354  * is released, but not destroyed until its refcount goes to zero.      That
 355  * handles the situation where DropCachedPlan is called while the plan is
 356  * still in use.
 357  */
 358 void
 359 DropCachedPlan(CachedPlanSource *plansource)
 360 {
 361         /* Validity check that we were given a CachedPlanSource */
 362         Assert(list_member_ptr(cached_plans_list, plansource));
 363
 364         /* Remove it from the list */
 365         cached_plans_list = list_delete_ptr(cached_plans_list, plansource);
 366
 367         /* Decrement child CachePlan's refcount and drop if no longer needed */
 368         if (plansource->plan)
 369                 ReleaseCachedPlan(plansource->plan, false);
 370
 371         /*
 372          * If CachedPlanSource has independent storage, just drop it.  Otherwise
 373          * decrement the refcount on the CachePlan that owns the storage.
 374          */
 375         if (plansource->orig_plan == NULL)
 376         {
 377                 /* Remove the CachedPlanSource and all subsidiary data */
 378                 MemoryContextDelete(plansource->context);
 379         }
 380         else
 381         {
 382                 Assert(plansource->context == plansource->orig_plan->context);
 383                 ReleaseCachedPlan(plansource->orig_plan, false);
 384         }
 385 }
 386
 387 /*
 388  * RevalidateCachedPlan: prepare for re-use of a previously cached plan.
 389  *
 390  * What we do here is re-acquire locks and rebuild the plan if necessary.
 391  * On return, the plan is valid and we have sufficient locks to begin
 392  * execution (or planning, if not fully_planned).
 393  *
 394  * On return, the refcount of the plan has been incremented; a later
 395  * ReleaseCachedPlan() call is expected.  The refcount has been reported
 396  * to the CurrentResourceOwner if useResOwner is true.
 397  *
 398  * Note: if any replanning activity is required, the caller's memory context
 399  * is used for that work.
 400  */
 401 CachedPlan *
 402 RevalidateCachedPlan(CachedPlanSource *plansource, bool useResOwner)
 403 {
 404         CachedPlan *plan;
 405
 406         /* Validity check that we were given a CachedPlanSource */
 407         Assert(list_member_ptr(cached_plans_list, plansource));
 408
 409         /*
 410          * If the plan currently appears valid, acquire locks on the referenced
 411          * objects; then check again.  We need to do it this way to cover the race
 412          * condition that an invalidation message arrives before we get the lock.
 413          */
 414         plan = plansource->plan;
 415         if (plan && !plan->dead)
 416         {
 417                 /*
 418                  * Plan must have positive refcount because it is referenced by
 419                  * plansource; so no need to fear it disappears under us here.
 420                  */
 421                 Assert(plan->refcount > 0);
 422
 423                 if (plan->fully_planned)
 424                         AcquireExecutorLocks(plan->stmt_list, true);
 425                 else
 426                         AcquirePlannerLocks(plan->stmt_list, true);
 427
 428                 /*
 429                  * If plan was transient, check to see if TransactionXmin has
 430                  * advanced, and if so invalidate it.
 431                  */
 432                 if (!plan->dead &&
 433                         TransactionIdIsValid(plan->saved_xmin) &&
 434                         !TransactionIdEquals(plan->saved_xmin, TransactionXmin))
 435                         plan->dead = true;
 436
 437                 /*
 438                  * By now, if any invalidation has happened, the inval callback
 439                  * functions will have marked the plan dead.
 440                  */
 441                 if (plan->dead)
 442                 {
 443                         /* Ooops, the race case happened.  Release useless locks. */
 444                         if (plan->fully_planned)
 445                                 AcquireExecutorLocks(plan->stmt_list, false);
 446                         else
 447                                 AcquirePlannerLocks(plan->stmt_list, false);
 448                 }
 449         }
 450
 451         /*
 452          * If plan has been invalidated, unlink it from the parent and release it.
 453          */
 454         if (plan && plan->dead)
 455         {
 456                 plansource->plan = NULL;
 457                 ReleaseCachedPlan(plan, false);
 458                 plan = NULL;
 459         }
 460
 461         /*
 462          * Build a new plan if needed.
 463          */
 464         if (!plan)
 465         {
 466                 bool            snapshot_set = false;
 467                 List       *slist;
 468                 TupleDesc       resultDesc;
 469
 470                 /*
 471                  * Restore the search_path that was in use when the plan was made.
 472                  * (XXX is there anything else we really need to restore?)
 473                  */
 474                 PushOverrideSearchPath(plansource->search_path);
 475
 476                 /*
 477                  * If a snapshot is already set (the normal case), we can just use
 478                  * that for parsing/planning.  But if it isn't, install one.  Note: no
 479                  * point in checking whether parse analysis requires a snapshot;
 480                  * utility commands don't have invalidatable plans, so we'd not get
 481                  * here for such a command.
 482                  */
 483                 if (!ActiveSnapshotSet())
 484                 {
 485                         PushActiveSnapshot(GetTransactionSnapshot());
 486                         snapshot_set = true;
 487                 }
 488
 489                 /*
 490                  * Run parse analysis and rule rewriting.  The parser tends to
 491                  * scribble on its input, so we must copy the raw parse tree to
 492                  * prevent corruption of the cache.  Note that we do not use
 493                  * parse_analyze_varparams(), assuming that the caller never wants the
 494                  * parameter types to change from the original values.
 495                  */
 496                 slist = pg_analyze_and_rewrite(copyObject(plansource->raw_parse_tree),
 497                                                                            plansource->query_string,
 498                                                                            plansource->param_types,
 499                                                                            plansource->num_params);
 500
 501                 if (plansource->fully_planned)
 502                 {
 503                         /*
 504                          * Generate plans for queries.
 505                          */
 506                         slist = pg_plan_queries(slist, plansource->cursor_options, NULL);
 507                 }
 508
 509                 /*
 510                  * Check or update the result tupdesc.  XXX should we use a weaker
 511                  * condition than equalTupleDescs() here?
 512                  */
 513                 resultDesc = PlanCacheComputeResultDesc(slist);
 514                 if (resultDesc == NULL && plansource->resultDesc == NULL)
 515                 {
 516                         /* OK, doesn't return tuples */
 517                 }
 518                 else if (resultDesc == NULL || plansource->resultDesc == NULL ||
 519                                  !equalTupleDescs(resultDesc, plansource->resultDesc))
 520                 {
 521                         MemoryContext oldcxt;
 522
 523                         /* can we give a better error message? */
 524                         if (plansource->fixed_result)
 525                                 ereport(ERROR,
 526                                                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 527                                                  errmsg("cached plan must not change result type")));
 528                         oldcxt = MemoryContextSwitchTo(plansource->context);
 529                         if (resultDesc)
 530                                 resultDesc = CreateTupleDescCopy(resultDesc);
 531                         if (plansource->resultDesc)
 532                                 FreeTupleDesc(plansource->resultDesc);
 533                         plansource->resultDesc = resultDesc;
 534                         MemoryContextSwitchTo(oldcxt);
 535                 }
 536
 537                 /* Release snapshot if we got one */
 538                 if (snapshot_set)
 539                         PopActiveSnapshot();
 540
 541                 /* Now we can restore current search path */
 542                 PopOverrideSearchPath();
 543
 544                 /*
 545                  * Store the plans into the plancache entry, advancing the generation
 546                  * count.
 547                  */
 548                 StoreCachedPlan(plansource, slist, NULL);
 549
 550                 plan = plansource->plan;
 551         }
 552
 553         /*
 554          * Last step: flag the plan as in use by caller.
 555          */
 556         if (useResOwner)
 557                 ResourceOwnerEnlargePlanCacheRefs(CurrentResourceOwner);
 558         plan->refcount++;
 559         if (useResOwner)
 560                 ResourceOwnerRememberPlanCacheRef(CurrentResourceOwner, plan);
 561
 562         return plan;
 563 }
 564
 565 /*
 566  * ReleaseCachedPlan: release active use of a cached plan.
 567  *
 568  * This decrements the reference count, and frees the plan if the count
 569  * has thereby gone to zero.  If useResOwner is true, it is assumed that
 570  * the reference count is managed by the CurrentResourceOwner.
 571  *
 572  * Note: useResOwner = false is used for releasing references that are in
 573  * persistent data structures, such as the parent CachedPlanSource or a
 574  * Portal.      Transient references should be protected by a resource owner.
 575  */
 576 void
 577 ReleaseCachedPlan(CachedPlan *plan, bool useResOwner)
 578 {
 579         if (useResOwner)
 580                 ResourceOwnerForgetPlanCacheRef(CurrentResourceOwner, plan);
 581         Assert(plan->refcount > 0);
 582         plan->refcount--;
 583         if (plan->refcount == 0)
 584                 MemoryContextDelete(plan->context);
 585 }
 586
 587 /*
 588  * CachedPlanIsValid: test whether the plan within a CachedPlanSource is
 589  * currently valid (that is, not marked as being in need of revalidation).
 590  *
 591  * This result is only trustworthy (ie, free from race conditions) if
 592  * the caller has acquired locks on all the relations used in the plan.
 593  */
 594 bool
 595 CachedPlanIsValid(CachedPlanSource *plansource)
 596 {
 597         CachedPlan *plan;
 598
 599         /* Validity check that we were given a CachedPlanSource */
 600         Assert(list_member_ptr(cached_plans_list, plansource));
 601
 602         plan = plansource->plan;
 603         if (plan && !plan->dead)
 604         {
 605                 /*
 606                  * Plan must have positive refcount because it is referenced by
 607                  * plansource; so no need to fear it disappears under us here.
 608                  */
 609                 Assert(plan->refcount > 0);
 610
 611                 /*
 612                  * Although we don't want to acquire locks here, it still seems useful
 613                  * to check for expiration of a transient plan.
 614                  */
 615                 if (TransactionIdIsValid(plan->saved_xmin) &&
 616                         !TransactionIdEquals(plan->saved_xmin, TransactionXmin))
 617                         plan->dead = true;
 618                 else
 619                         return true;
 620         }
 621
 622         return false;
 623 }
 624
 625 /*
 626  * AcquireExecutorLocks: acquire locks needed for execution of a fully-planned
 627  * cached plan; or release them if acquire is false.
 628  */
 629 static void
 630 AcquireExecutorLocks(List *stmt_list, bool acquire)
 631 {
 632         ListCell   *lc1;
 633
 634         foreach(lc1, stmt_list)
 635         {
 636                 PlannedStmt *plannedstmt = (PlannedStmt *) lfirst(lc1);
 637                 int                     rt_index;
 638                 ListCell   *lc2;
 639
 640                 Assert(!IsA(plannedstmt, Query));
 641                 if (!IsA(plannedstmt, PlannedStmt))
 642                         continue;                       /* Ignore utility statements */
 643
 644                 rt_index = 0;
 645                 foreach(lc2, plannedstmt->rtable)
 646                 {
 647                         RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc2);
 648                         LOCKMODE        lockmode;
 649
 650                         rt_index++;
 651
 652                         if (rte->rtekind != RTE_RELATION)
 653                                 continue;
 654
 655                         /*
 656                          * Acquire the appropriate type of lock on each relation OID. Note
 657                          * that we don't actually try to open the rel, and hence will not
 658                          * fail if it's been dropped entirely --- we'll just transiently
 659                          * acquire a non-conflicting lock.
 660                          */
 661                         if (list_member_int(plannedstmt->resultRelations, rt_index))
 662                                 lockmode = RowExclusiveLock;
 663                         else if (rowmark_member(plannedstmt->rowMarks, rt_index))
 664                                 lockmode = RowShareLock;
 665                         else
 666                                 lockmode = AccessShareLock;
 667
 668                         if (acquire)
 669                                 LockRelationOid(rte->relid, lockmode);
 670                         else
 671                                 UnlockRelationOid(rte->relid, lockmode);
 672                 }
 673         }
 674 }
 675
 676 /*
 677  * AcquirePlannerLocks: acquire locks needed for planning and execution of a
 678  * not-fully-planned cached plan; or release them if acquire is false.
 679  *
 680  * Note that we don't actually try to open the relations, and hence will not
 681  * fail if one has been dropped entirely --- we'll just transiently acquire
 682  * a non-conflicting lock.
 683  */
 684 static void
 685 AcquirePlannerLocks(List *stmt_list, bool acquire)
 686 {
 687         ListCell   *lc;
 688
 689         foreach(lc, stmt_list)
 690         {
 691                 Query      *query = (Query *) lfirst(lc);
 692
 693                 Assert(IsA(query, Query));
 694                 ScanQueryForLocks(query, acquire);
 695         }
 696 }
 697
 698 /*
 699  * ScanQueryForLocks: recursively scan one Query for AcquirePlannerLocks.
 700  */
 701 static void
 702 ScanQueryForLocks(Query *parsetree, bool acquire)
 703 {
 704         ListCell   *lc;
 705         int                     rt_index;
 706
 707         /*
 708          * First, process RTEs of the current query level.
 709          */
 710         rt_index = 0;
 711         foreach(lc, parsetree->rtable)
 712         {
 713                 RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc);
 714                 LOCKMODE        lockmode;
 715
 716                 rt_index++;
 717                 switch (rte->rtekind)
 718                 {
 719                         case RTE_RELATION:
 720                                 /* Acquire or release the appropriate type of lock */
 721                                 if (rt_index == parsetree->resultRelation)
 722                                         lockmode = RowExclusiveLock;
 723                                 else if (rowmark_member(parsetree->rowMarks, rt_index))
 724                                         lockmode = RowShareLock;
 725                                 else
 726                                         lockmode = AccessShareLock;
 727                                 if (acquire)
 728                                         LockRelationOid(rte->relid, lockmode);
 729                                 else
 730                                         UnlockRelationOid(rte->relid, lockmode);
 731                                 break;
 732
 733                         case RTE_SUBQUERY:
 734                                 /* Recurse into subquery-in-FROM */
 735                                 ScanQueryForLocks(rte->subquery, acquire);
 736                                 break;
 737
 738                         default:
 739                                 /* ignore other types of RTEs */
 740                                 break;
 741                 }
 742         }
 743
 744         /* Recurse into subquery-in-WITH */
 745         foreach(lc, parsetree->cteList)
 746         {
 747                 CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
 748
 749                 ScanQueryForLocks((Query *) cte->ctequery, acquire);
 750         }
 751
 752         /*
 753          * Recurse into sublink subqueries, too.  But we already did the ones in
 754          * the rtable and cteList.
 755          */
 756         if (parsetree->hasSubLinks)
 757         {
 758                 query_tree_walker(parsetree, ScanQueryWalker,
 759                                                   (void *) &acquire,
 760                                                   QTW_IGNORE_RC_SUBQUERIES);
 761         }
 762 }
 763
 764 /*
 765  * Walker to find sublink subqueries for ScanQueryForLocks
 766  */
 767 static bool
 768 ScanQueryWalker(Node *node, bool *acquire)
 769 {
 770         if (node == NULL)
 771                 return false;
 772         if (IsA(node, SubLink))
 773         {
 774                 SubLink    *sub = (SubLink *) node;
 775
 776                 /* Do what we came for */
 777                 ScanQueryForLocks((Query *) sub->subselect, *acquire);
 778                 /* Fall through to process lefthand args of SubLink */
 779         }
 780
 781         /*
 782          * Do NOT recurse into Query nodes, because ScanQueryForLocks already
 783          * processed subselects of subselects for us.
 784          */
 785         return expression_tree_walker(node, ScanQueryWalker,
 786                                                                   (void *) acquire);
 787 }
 788
 789 /*
 790  * rowmark_member: check whether an RT index appears in a RowMarkClause list.
 791  */
 792 static bool
 793 rowmark_member(List *rowMarks, int rt_index)
 794 {
 795         ListCell   *l;
 796
 797         foreach(l, rowMarks)
 798         {
 799                 RowMarkClause *rc = (RowMarkClause *) lfirst(l);
 800
 801                 if (rc->rti == rt_index)
 802                         return true;
 803         }
 804         return false;
 805 }
 806
 807 /*
 808  * plan_list_is_transient: check if any of the plans in the list are transient.
 809  */
 810 static bool
 811 plan_list_is_transient(List *stmt_list)
 812 {
 813         ListCell   *lc;
 814
 815         foreach(lc, stmt_list)
 816         {
 817                 PlannedStmt *plannedstmt = (PlannedStmt *) lfirst(lc);
 818
 819                 if (!IsA(plannedstmt, PlannedStmt))
 820                         continue;                       /* Ignore utility statements */
 821
 822                 if (plannedstmt->transientPlan)
 823                         return true;
 824         }
 825
 826         return false;
 827 }
 828
 829 /*
 830  * PlanCacheComputeResultDesc: given a list of either fully-planned statements
 831  * or Queries, determine the result tupledesc it will produce.  Returns NULL
 832  * if the execution will not return tuples.
 833  *
 834  * Note: the result is created or copied into current memory context.
 835  */
 836 TupleDesc
 837 PlanCacheComputeResultDesc(List *stmt_list)
 838 {
 839         Node       *node;
 840         Query      *query;
 841         PlannedStmt *pstmt;
 842
 843         switch (ChoosePortalStrategy(stmt_list))
 844         {
 845                 case PORTAL_ONE_SELECT:
 846                         node = (Node *) linitial(stmt_list);
 847                         if (IsA(node, Query))
 848                         {
 849                                 query = (Query *) node;
 850                                 return ExecCleanTypeFromTL(query->targetList, false);
 851                         }
 852                         if (IsA(node, PlannedStmt))
 853                         {
 854                                 pstmt = (PlannedStmt *) node;
 855                                 return ExecCleanTypeFromTL(pstmt->planTree->targetlist, false);
 856                         }
 857                         /* other cases shouldn't happen, but return NULL */
 858                         break;
 859
 860                 case PORTAL_ONE_RETURNING:
 861                         node = PortalListGetPrimaryStmt(stmt_list);
 862                         if (IsA(node, Query))
 863                         {
 864                                 query = (Query *) node;
 865                                 Assert(query->returningList);
 866                                 return ExecCleanTypeFromTL(query->returningList, false);
 867                         }
 868                         if (IsA(node, PlannedStmt))
 869                         {
 870                                 pstmt = (PlannedStmt *) node;
 871                                 Assert(pstmt->returningLists);
 872                                 return ExecCleanTypeFromTL((List *) linitial(pstmt->returningLists), false);
 873                         }
 874                         /* other cases shouldn't happen, but return NULL */
 875                         break;
 876
 877                 case PORTAL_UTIL_SELECT:
 878                         node = (Node *) linitial(stmt_list);
 879                         if (IsA(node, Query))
 880                         {
 881                                 query = (Query *) node;
 882                                 Assert(query->utilityStmt);
 883                                 return UtilityTupleDescriptor(query->utilityStmt);
 884                         }
 885                         /* else it's a bare utility statement */
 886                         return UtilityTupleDescriptor(node);
 887
 888                 case PORTAL_MULTI_QUERY:
 889                         /* will not return tuples */
 890                         break;
 891         }
 892         return NULL;
 893 }
 894
 895 /*
 896  * PlanCacheRelCallback
 897  *              Relcache inval callback function
 898  *
 899  * Invalidate all plans mentioning the given rel, or all plans mentioning
 900  * any rel at all if relid == InvalidOid.
 901  */
 902 static void
 903 PlanCacheRelCallback(Datum arg, Oid relid)
 904 {
 905         ListCell   *lc1;
 906
 907         foreach(lc1, cached_plans_list)
 908         {
 909                 CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc1);
 910                 CachedPlan *plan = plansource->plan;
 911
 912                 /* No work if it's already invalidated */
 913                 if (!plan || plan->dead)
 914                         continue;
 915                 if (plan->fully_planned)
 916                 {
 917                         /* Have to check the per-PlannedStmt relid lists */
 918                         ListCell   *lc2;
 919
 920                         foreach(lc2, plan->stmt_list)
 921                         {
 922                                 PlannedStmt *plannedstmt = (PlannedStmt *) lfirst(lc2);
 923
 924                                 Assert(!IsA(plannedstmt, Query));
 925                                 if (!IsA(plannedstmt, PlannedStmt))
 926                                         continue;       /* Ignore utility statements */
 927                                 if ((relid == InvalidOid) ? plannedstmt->relationOids != NIL :
 928                                         list_member_oid(plannedstmt->relationOids, relid))
 929                                 {
 930                                         /* Invalidate the plan! */
 931                                         plan->dead = true;
 932                                         break;          /* out of stmt_list scan */
 933                                 }
 934                         }
 935                 }
 936                 else
 937                 {
 938                         /* Otherwise check the single list we built ourselves */
 939                         if ((relid == InvalidOid) ? plan->relationOids != NIL :
 940                                 list_member_oid(plan->relationOids, relid))
 941                                 plan->dead = true;
 942                 }
 943         }
 944 }
 945
 946 /*
 947  * PlanCacheFuncCallback
 948  *              Syscache inval callback function for PROCOID cache
 949  *
 950  * Invalidate all plans mentioning the given catalog entry, or all plans
 951  * mentioning any member of this cache if tuplePtr == NULL.
 952  *
 953  * Note that the coding would support use for multiple caches, but right
 954  * now only user-defined functions are tracked this way.
 955  */
 956 static void
 957 PlanCacheFuncCallback(Datum arg, int cacheid, ItemPointer tuplePtr)
 958 {
 959         ListCell   *lc1;
 960
 961         foreach(lc1, cached_plans_list)
 962         {
 963                 CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc1);
 964                 CachedPlan *plan = plansource->plan;
 965
 966                 /* No work if it's already invalidated */
 967                 if (!plan || plan->dead)
 968                         continue;
 969                 if (plan->fully_planned)
 970                 {
 971                         /* Have to check the per-PlannedStmt inval-item lists */
 972                         ListCell   *lc2;
 973
 974                         foreach(lc2, plan->stmt_list)
 975                         {
 976                                 PlannedStmt *plannedstmt = (PlannedStmt *) lfirst(lc2);
 977                                 ListCell   *lc3;
 978
 979                                 Assert(!IsA(plannedstmt, Query));
 980                                 if (!IsA(plannedstmt, PlannedStmt))
 981                                         continue;       /* Ignore utility statements */
 982                                 foreach(lc3, plannedstmt->invalItems)
 983                                 {
 984                                         PlanInvalItem *item = (PlanInvalItem *) lfirst(lc3);
 985
 986                                         if (item->cacheId != cacheid)
 987                                                 continue;
 988                                         if (tuplePtr == NULL ||
 989                                                 ItemPointerEquals(tuplePtr, &item->tupleId))
 990                                         {
 991                                                 /* Invalidate the plan! */
 992                                                 plan->dead = true;
 993                                                 break;  /* out of invalItems scan */
 994                                         }
 995                                 }
 996                                 if (plan->dead)
 997                                         break;          /* out of stmt_list scan */
 998                         }
 999                 }
1000                 else
1001                 {
1002                         /* Otherwise check the single list we built ourselves */
1003                         ListCell   *lc2;
1004
1005                         foreach(lc2, plan->invalItems)
1006                         {
1007                                 PlanInvalItem *item = (PlanInvalItem *) lfirst(lc2);
1008
1009                                 if (item->cacheId != cacheid)
1010                                         continue;
1011                                 if (tuplePtr == NULL ||
1012                                         ItemPointerEquals(tuplePtr, &item->tupleId))
1013                                 {
1014                                         /* Invalidate the plan! */
1015                                         plan->dead = true;
1016                                         break;
1017                                 }
1018                         }
1019                 }
1020         }
1021 }
1022
1023 /*
1024  * PlanCacheSysCallback
1025  *              Syscache inval callback function for other caches
1026  *
1027  * Just invalidate everything...
1028  */
1029 static void
1030 PlanCacheSysCallback(Datum arg, int cacheid, ItemPointer tuplePtr)
1031 {
1032         ResetPlanCache();
1033 }
1034
1035 /*
1036  * ResetPlanCache: drop all cached plans.
1037  */
1038 void
1039 ResetPlanCache(void)
1040 {
1041         ListCell   *lc;
1042
1043         foreach(lc, cached_plans_list)
1044         {
1045                 CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
1046                 CachedPlan *plan = plansource->plan;
1047
1048                 if (plan)
1049                         plan->dead = true;
1050         }
1051 }