diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c index 1ffc823..544f423 100644 *** a/src/backend/commands/typecmds.c --- b/src/backend/commands/typecmds.c *************** *** 62,67 **** --- 62,68 ---- #include "parser/parse_type.h" #include "utils/builtins.h" #include "utils/fmgroids.h" + #include "utils/inval.h" #include "utils/lsyscache.h" #include "utils/memutils.h" #include "utils/rel.h" *************** AlterDomainDefault(List *names, Node *de *** 2297,2303 **** ObjectAddressSet(address, TypeRelationId, domainoid); /* Clean up */ ! heap_close(rel, NoLock); heap_freetuple(newtuple); return address; --- 2298,2304 ---- ObjectAddressSet(address, TypeRelationId, domainoid); /* Clean up */ ! heap_close(rel, RowExclusiveLock); heap_freetuple(newtuple); return address; *************** AlterDomainDropConstraint(List *names, c *** 2494,2501 **** systable_endscan(conscan); heap_close(conrel, RowExclusiveLock); - heap_close(rel, NoLock); - if (!found) { if (!missing_ok) --- 2495,2500 ---- *************** AlterDomainDropConstraint(List *names, c *** 2509,2516 **** --- 2508,2525 ---- constrName, TypeNameToString(typename)))); } + /* + * We must send out an sinval message for the domain, to ensure that any + * dependent plans get rebuilt. Since this command doesn't change the + * domain's pg_type row, that won't happen automatically; do it manually. + */ + CacheInvalidateHeapTuple(rel, tup, NULL); + ObjectAddressSet(address, TypeRelationId, domainoid); + /* Clean up */ + heap_close(rel, RowExclusiveLock); + return address; } *************** AlterDomainAddConstraint(List *names, No *** 2615,2620 **** --- 2624,2636 ---- if (!constr->skip_validation) validateDomainConstraint(domainoid, ccbin); + /* + * We must send out an sinval message for the domain, to ensure that any + * dependent plans get rebuilt. Since this command doesn't change the + * domain's pg_type row, that won't happen automatically; do it manually. + */ + CacheInvalidateHeapTuple(typrel, tup, NULL); + ObjectAddressSet(address, TypeRelationId, domainoid); /* Clean up */ diff --git a/src/backend/optimizer/plan/planner.c b/src/backend/optimizer/plan/planner.c index c729a99..b645648 100644 *** a/src/backend/optimizer/plan/planner.c --- b/src/backend/optimizer/plan/planner.c *************** adjust_paths_for_srfs(PlannerInfo *root, *** 5923,5932 **** * side-effect that is useful when the expression will get evaluated more than * once. Also, we must fix operator function IDs. * * Note: this must not make any damaging changes to the passed-in expression * tree. (It would actually be okay to apply fix_opfuncids to it, but since * we first do an expression_tree_mutator-based walk, what is returned will ! * be a new node tree.) */ Expr * expression_planner(Expr *expr) --- 5923,5938 ---- * side-effect that is useful when the expression will get evaluated more than * once. Also, we must fix operator function IDs. * + * This does not return any information about dependencies of the expression. + * Hence callers should use the results only for the duration of the current + * query. Callers that would like to cache the results for longer should use + * expression_planner_with_deps, probably via the plancache. + * * Note: this must not make any damaging changes to the passed-in expression * tree. (It would actually be okay to apply fix_opfuncids to it, but since * we first do an expression_tree_mutator-based walk, what is returned will ! * be a new node tree.) The result is constructed in the current memory ! * context; beware that this can leak a lot of additional stuff there, too. */ Expr * expression_planner(Expr *expr) *************** expression_planner(Expr *expr) *** 5945,5950 **** --- 5951,6007 ---- return (Expr *) result; } + /* + * expression_planner_with_deps + * Perform planner's transformations on a standalone expression, + * returning expression dependency information along with the result. + * + * This is identical to expression_planner() except that it also returns + * information about possible dependencies of the expression, ie identities of + * objects whose definitions affect the result. As in a PlannedStmt, these + * are expressed as a list of relation Oids and a list of PlanInvalItems. + */ + Expr * + expression_planner_with_deps(Expr *expr, + List **relationOids, + List **invalItems) + { + Node *result; + PlannerGlobal glob; + PlannerInfo root; + + /* Make up dummy planner state so we can use setrefs machinery */ + MemSet(&glob, 0, sizeof(glob)); + glob.type = T_PlannerGlobal; + glob.relationOids = NIL; + glob.invalItems = NIL; + + MemSet(&root, 0, sizeof(root)); + root.type = T_PlannerInfo; + root.glob = &glob; + + /* + * Convert named-argument function calls, insert default arguments and + * simplify constant subexprs. Collect identities of inlined functions + * and elided domains, too. + */ + result = eval_const_expressions(&root, (Node *) expr); + + /* Fill in opfuncid values if missing */ + fix_opfuncids(result); + + /* + * Now walk the finished expression to find anything else we ought to + * record as an expression dependency. + */ + (void) extract_query_dependencies_walker(result, &root); + + *relationOids = glob.relationOids; + *invalItems = glob.invalItems; + + return (Expr *) result; + } + /* * plan_cluster_use_sort diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c index 6d6ef1c..a718e15 100644 *** a/src/backend/optimizer/plan/setrefs.c --- b/src/backend/optimizer/plan/setrefs.c *************** static List *set_returning_clause_refere *** 138,145 **** Plan *topplan, Index resultRelation, int rtoffset); ! static bool extract_query_dependencies_walker(Node *node, ! PlannerInfo *context); /***************************************************************************** * --- 138,144 ---- Plan *topplan, Index resultRelation, int rtoffset); ! /***************************************************************************** * *************** static bool extract_query_dependencies_w *** 175,182 **** * This will be used by plancache.c to drive invalidation of cached plans. * Relation dependencies are represented by OIDs, and everything else by * PlanInvalItems (this distinction is motivated by the shared-inval APIs). ! * Currently, relations and user-defined functions are the only types of ! * objects that are explicitly tracked this way. * * 8. We assign every plan node in the tree a unique ID. * --- 174,181 ---- * This will be used by plancache.c to drive invalidation of cached plans. * Relation dependencies are represented by OIDs, and everything else by * PlanInvalItems (this distinction is motivated by the shared-inval APIs). ! * Currently, relations, user-defined functions, and domains are the only ! * types of objects that are explicitly tracked this way. * * 8. We assign every plan node in the tree a unique ID. * *************** record_plan_function_dependency(PlannerI *** 2576,2581 **** --- 2575,2616 ---- } /* + * record_plan_type_dependency + * Mark the current plan as depending on a particular type. + * + * This is exported so that eval_const_expressions can record a + * dependency on a domain that it's removed a CoerceToDomain node for. + * + * We don't currently need to record dependencies on domains that the + * plan contains CoerceToDomain nodes for, though that might change in + * future. Hence, this isn't actually called in this module, though + * someday fix_expr_common might call it. + */ + void + record_plan_type_dependency(PlannerInfo *root, Oid typeid) + { + /* + * As in record_plan_function_dependency, ignore the possibility that + * someone would change a built-in domain. + */ + if (typeid >= (Oid) FirstBootstrapObjectId) + { + PlanInvalItem *inval_item = makeNode(PlanInvalItem); + + /* + * It would work to use any syscache on pg_type, but the easiest is + * TYPEOID since we already have the type's OID at hand. Note that + * plancache.c knows we use TYPEOID. + */ + inval_item->cacheId = TYPEOID; + inval_item->hashValue = GetSysCacheHashValue1(TYPEOID, + ObjectIdGetDatum(typeid)); + + root->glob->invalItems = lappend(root->glob->invalItems, inval_item); + } + } + + /* * extract_query_dependencies * Given a rewritten, but not yet planned, query or queries * (i.e. a Query node or list of Query nodes), extract dependencies *************** record_plan_function_dependency(PlannerI *** 2584,2589 **** --- 2619,2631 ---- * * This is needed by plancache.c to handle invalidation of cached unplanned * queries. + * + * Note: this does not go through eval_const_expressions, and hence doesn't + * reflect its additions of inlined functions and elided CoerceToDomain nodes + * to the invalItems list. This is obviously OK for functions, since we'll + * see them in the original query tree anyway. For domains, it's OK because + * we don't care about domains unless they get elided. That is, a plan might + * have domain dependencies that the query tree doesn't. */ void extract_query_dependencies(Node *query, *************** extract_query_dependencies(Node *query, *** 2613,2626 **** *hasRowSecurity = glob.dependsOnRole; } ! static bool extract_query_dependencies_walker(Node *node, PlannerInfo *context) { if (node == NULL) return false; Assert(!IsA(node, PlaceHolderVar)); - /* Extract function dependencies and check for regclass Consts */ - fix_expr_common(context, node); if (IsA(node, Query)) { Query *query = (Query *) node; --- 2655,2674 ---- *hasRowSecurity = glob.dependsOnRole; } ! /* ! * Tree walker for extract_query_dependencies. ! * ! * This is exported so that expression_planner_with_deps can call it on ! * simple expressions (post-planning, not before planning, in that case). ! * In that usage, glob.dependsOnRole isn't meaningful, but the relationOids ! * and invalItems lists are added to as needed. ! */ ! bool extract_query_dependencies_walker(Node *node, PlannerInfo *context) { if (node == NULL) return false; Assert(!IsA(node, PlaceHolderVar)); if (IsA(node, Query)) { Query *query = (Query *) node; *************** extract_query_dependencies_walker(Node * *** 2660,2665 **** --- 2708,2715 ---- return query_tree_walker(query, extract_query_dependencies_walker, (void *) context, 0); } + /* Extract function dependencies and check for regclass Consts */ + fix_expr_common(context, node); return expression_tree_walker(node, extract_query_dependencies_walker, (void *) context); } diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c index 8df3693..f444616 100644 *** a/src/backend/optimizer/util/clauses.c --- b/src/backend/optimizer/util/clauses.c *************** eval_const_expressions_mutator(Node *nod *** 3699,3704 **** --- 3699,3768 ---- newbtest->location = btest->location; return (Node *) newbtest; } + case T_CoerceToDomain: + { + /* + * If the domain currently has no constraints, we replace the + * CoerceToDomain node with a simple RelabelType, which is + * both far faster to execute and more amenable to later + * optimization. We must then mark the plan as needing to be + * rebuilt if the domain's constraints change. + * + * Also, in estimation mode, always replace CoerceToDomain + * nodes, effectively assuming that the coercion will succeed. + */ + CoerceToDomain *cdomain = (CoerceToDomain *) node; + CoerceToDomain *newcdomain; + Node *arg; + + arg = eval_const_expressions_mutator((Node *) cdomain->arg, + context); + if (context->estimate || + !DomainHasConstraints(cdomain->resulttype)) + { + /* Record dependency, if this isn't estimation mode */ + if (context->root && !context->estimate) + record_plan_type_dependency(context->root, + cdomain->resulttype); + + /* Generate RelabelType to substitute for CoerceToDomain */ + /* This should match the RelabelType logic above */ + + while (arg && IsA(arg, RelabelType)) + arg = (Node *) ((RelabelType *) arg)->arg; + + if (arg && IsA(arg, Const)) + { + Const *con = (Const *) arg; + + con->consttype = cdomain->resulttype; + con->consttypmod = cdomain->resulttypmod; + con->constcollid = cdomain->resultcollid; + return (Node *) con; + } + else + { + RelabelType *newrelabel = makeNode(RelabelType); + + newrelabel->arg = (Expr *) arg; + newrelabel->resulttype = cdomain->resulttype; + newrelabel->resulttypmod = cdomain->resulttypmod; + newrelabel->resultcollid = cdomain->resultcollid; + newrelabel->relabelformat = cdomain->coercionformat; + newrelabel->location = cdomain->location; + return (Node *) newrelabel; + } + } + + newcdomain = makeNode(CoerceToDomain); + newcdomain->arg = (Expr *) arg; + newcdomain->resulttype = cdomain->resulttype; + newcdomain->resulttypmod = cdomain->resulttypmod; + newcdomain->resultcollid = cdomain->resultcollid; + newcdomain->coercionformat = cdomain->coercionformat; + newcdomain->location = cdomain->location; + return (Node *) newcdomain; + } case T_PlaceHolderVar: /* *************** eval_const_expressions_mutator(Node *nod *** 3770,3776 **** * For any node type not handled above, copy the node unchanged but * const-simplify its subexpressions. This is the correct thing for node * types whose behavior might change between planning and execution, such ! * as CoerceToDomain. It's also a safe default for new node types not * known to this routine. */ return ece_generic_processing(node); --- 3834,3840 ---- * For any node type not handled above, copy the node unchanged but * const-simplify its subexpressions. This is the correct thing for node * types whose behavior might change between planning and execution, such ! * as CurrentOfExpr. It's also a safe default for new node types not * known to this routine. */ return ece_generic_processing(node); diff --git a/src/backend/utils/cache/plancache.c b/src/backend/utils/cache/plancache.c index 9ec81c5..a3898ec 100644 *** a/src/backend/utils/cache/plancache.c --- b/src/backend/utils/cache/plancache.c *************** *** 27,41 **** * query to change output tupdesc on replan --- if so, it's up to the * caller to notice changes and cope with them. * ! * Currently, we track exactly the dependencies of plans on relations and ! * user-defined functions. On relcache invalidation events or pg_proc ! * syscache invalidation events, we invalidate just those plans that depend ! * on the particular object being modified. (Note: this scheme assumes ! * that any table modification that requires replanning will generate a ! * relcache inval event.) We also watch for inval events on certain other ! * system catalogs, such as pg_namespace; but for them, our response is ! * just to invalidate all plans. We expect updates on those catalogs to ! * be infrequent enough that more-detailed tracking is not worth the effort. * * * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group --- 27,47 ---- * query to change output tupdesc on replan --- if so, it's up to the * caller to notice changes and cope with them. * ! * Currently, we track exactly the dependencies of plans on relations, ! * user-defined functions, and domains. On relcache invalidation events or ! * pg_proc or pg_type syscache invalidation events, we invalidate just those ! * plans that depend on the particular object being modified. (Note: this ! * scheme assumes that any table modification that requires replanning will ! * generate a relcache inval event.) We also watch for inval events on ! * certain other system catalogs, such as pg_namespace; but for them, our ! * response is just to invalidate all plans. We expect updates on those ! * catalogs to be infrequent enough that more-detailed tracking is not worth ! * the effort. ! * ! * In addition to full-fledged query plans, we provide a facility for ! * detecting invalidations of simple scalar expressions. This is fairly ! * bare-bones; it's the caller's responsibility to build a new expression ! * if the old one gets invalidated. * * * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group *************** *** 57,62 **** --- 63,69 ---- #include "nodes/nodeFuncs.h" #include "optimizer/cost.h" #include "optimizer/planmain.h" + #include "optimizer/planner.h" #include "optimizer/prep.h" #include "parser/analyze.h" #include "parser/parsetree.h" *************** *** 82,91 **** /* * This is the head of the backend's list of "saved" CachedPlanSources (i.e., * those that are in long-lived storage and are examined for sinval events). ! * We thread the structs manually instead of using List cells so that we can ! * guarantee to save a CachedPlanSource without error. */ ! static CachedPlanSource *first_saved_plan = NULL; static void ReleaseGenericPlan(CachedPlanSource *plansource); static List *RevalidateCachedQuery(CachedPlanSource *plansource, --- 89,103 ---- /* * This is the head of the backend's list of "saved" CachedPlanSources (i.e., * those that are in long-lived storage and are examined for sinval events). ! * We use a dlist instead of separate List cells so that we can guarantee ! * to save a CachedPlanSource without error. */ ! static dlist_head saved_plan_list; ! ! /* ! * This is the head of the backend's list of CachedExpressions. ! */ ! static dlist_head cached_expression_list; static void ReleaseGenericPlan(CachedPlanSource *plansource); static List *RevalidateCachedQuery(CachedPlanSource *plansource, *************** static void ScanQueryForLocks(Query *par *** 103,109 **** static bool ScanQueryWalker(Node *node, bool *acquire); static TupleDesc PlanCacheComputeResultDesc(List *stmt_list); static void PlanCacheRelCallback(Datum arg, Oid relid); ! static void PlanCacheFuncCallback(Datum arg, int cacheid, uint32 hashvalue); static void PlanCacheSysCallback(Datum arg, int cacheid, uint32 hashvalue); /* GUC parameter */ --- 115,121 ---- static bool ScanQueryWalker(Node *node, bool *acquire); static TupleDesc PlanCacheComputeResultDesc(List *stmt_list); static void PlanCacheRelCallback(Datum arg, Oid relid); ! static void PlanCacheObjectCallback(Datum arg, int cacheid, uint32 hashvalue); static void PlanCacheSysCallback(Datum arg, int cacheid, uint32 hashvalue); /* GUC parameter */ *************** void *** 118,124 **** InitPlanCache(void) { CacheRegisterRelcacheCallback(PlanCacheRelCallback, (Datum) 0); ! CacheRegisterSyscacheCallback(PROCOID, PlanCacheFuncCallback, (Datum) 0); CacheRegisterSyscacheCallback(NAMESPACEOID, PlanCacheSysCallback, (Datum) 0); CacheRegisterSyscacheCallback(OPEROID, PlanCacheSysCallback, (Datum) 0); CacheRegisterSyscacheCallback(AMOPOPID, PlanCacheSysCallback, (Datum) 0); --- 130,137 ---- InitPlanCache(void) { CacheRegisterRelcacheCallback(PlanCacheRelCallback, (Datum) 0); ! CacheRegisterSyscacheCallback(PROCOID, PlanCacheObjectCallback, (Datum) 0); ! CacheRegisterSyscacheCallback(TYPEOID, PlanCacheObjectCallback, (Datum) 0); CacheRegisterSyscacheCallback(NAMESPACEOID, PlanCacheSysCallback, (Datum) 0); CacheRegisterSyscacheCallback(OPEROID, PlanCacheSysCallback, (Datum) 0); CacheRegisterSyscacheCallback(AMOPOPID, PlanCacheSysCallback, (Datum) 0); *************** CreateCachedPlan(RawStmt *raw_parse_tree *** 206,212 **** plansource->is_saved = false; plansource->is_valid = false; plansource->generation = 0; - plansource->next_saved = NULL; plansource->generic_cost = -1; plansource->total_custom_cost = 0; plansource->num_custom_plans = 0; --- 219,224 ---- *************** CreateOneShotCachedPlan(RawStmt *raw_par *** 274,280 **** plansource->is_saved = false; plansource->is_valid = false; plansource->generation = 0; - plansource->next_saved = NULL; plansource->generic_cost = -1; plansource->total_custom_cost = 0; plansource->num_custom_plans = 0; --- 286,291 ---- *************** SaveCachedPlan(CachedPlanSource *plansou *** 471,478 **** /* * Add the entry to the global list of cached plans. */ ! plansource->next_saved = first_saved_plan; ! first_saved_plan = plansource; plansource->is_saved = true; } --- 482,488 ---- /* * Add the entry to the global list of cached plans. */ ! dlist_push_tail(&saved_plan_list, &plansource->node); plansource->is_saved = true; } *************** DropCachedPlan(CachedPlanSource *plansou *** 493,513 **** /* If it's been saved, remove it from the list */ if (plansource->is_saved) { ! if (first_saved_plan == plansource) ! first_saved_plan = plansource->next_saved; ! else ! { ! CachedPlanSource *psrc; ! ! for (psrc = first_saved_plan; psrc; psrc = psrc->next_saved) ! { ! if (psrc->next_saved == plansource) ! { ! psrc->next_saved = plansource->next_saved; ! break; ! } ! } ! } plansource->is_saved = false; } --- 503,509 ---- /* If it's been saved, remove it from the list */ if (plansource->is_saved) { ! dlist_delete(&plansource->node); plansource->is_saved = false; } *************** CopyCachedPlan(CachedPlanSource *plansou *** 1399,1405 **** newsource->is_saved = false; newsource->is_valid = plansource->is_valid; newsource->generation = plansource->generation; - newsource->next_saved = NULL; /* We may as well copy any acquired cost knowledge */ newsource->generic_cost = plansource->generic_cost; --- 1395,1400 ---- *************** CachedPlanGetTargetList(CachedPlanSource *** 1459,1464 **** --- 1454,1538 ---- } /* + * GetCachedExpression: construct a CachedExpression for an expression. + * + * This performs the same transformations on the expression as + * expression_planner(), ie, convert an expression as emitted by parse + * analysis to be ready to pass to the executor. + * + * The result is stashed in a private, long-lived memory context. + * (Note that this might leak a good deal of memory in the caller's + * context before that.) The passed-in expr tree is not modified. + */ + CachedExpression * + GetCachedExpression(Node *expr) + { + CachedExpression *cexpr; + List *relationOids; + List *invalItems; + MemoryContext cexpr_context; + MemoryContext oldcxt; + + /* + * Pass the expression through the planner, and collect dependencies. + * Everything built here is leaked in the caller's context; that's + * intentional to minimize the size of the permanent data structure. + */ + expr = (Node *) expression_planner_with_deps((Expr *) expr, + &relationOids, + &invalItems); + + /* + * Make a private memory context, and copy what we need into that. To + * avoid leaking a long-lived context if we fail while copying data, we + * initially make the context under the caller's context. + */ + cexpr_context = AllocSetContextCreate(CurrentMemoryContext, + "CachedExpression", + ALLOCSET_SMALL_SIZES); + + oldcxt = MemoryContextSwitchTo(cexpr_context); + + cexpr = (CachedExpression *) palloc(sizeof(CachedExpression)); + cexpr->magic = CACHEDEXPR_MAGIC; + cexpr->expr = copyObject(expr); + cexpr->is_valid = true; + cexpr->relationOids = copyObject(relationOids); + cexpr->invalItems = copyObject(invalItems); + cexpr->context = cexpr_context; + + MemoryContextSwitchTo(oldcxt); + + /* + * Reparent the expr's memory context under CacheMemoryContext so that it + * will live indefinitely. + */ + MemoryContextSetParent(cexpr->context, CacheMemoryContext); + + /* + * Add the entry to the global list of cached expressions. + */ + dlist_push_tail(&cached_expression_list, &cexpr->node); + + return cexpr; + } + + /* + * FreeCachedExpression + * Delete a CachedExpression. + */ + void + FreeCachedExpression(CachedExpression *cexpr) + { + /* Sanity check */ + Assert(cexpr->magic == CACHEDEXPR_MAGIC); + /* Unlink from global list */ + dlist_delete(&cexpr->node); + /* Free all storage associated with CachedExpression */ + MemoryContextDelete(cexpr->context); + } + + /* * QueryListGetPrimaryStmt * Get the "primary" stmt within a list, ie, the one marked canSetTag. * *************** PlanCacheComputeResultDesc(List *stmt_li *** 1692,1701 **** static void PlanCacheRelCallback(Datum arg, Oid relid) { ! CachedPlanSource *plansource; ! for (plansource = first_saved_plan; plansource; plansource = plansource->next_saved) { Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC); /* No work if it's already invalidated */ --- 1766,1778 ---- static void PlanCacheRelCallback(Datum arg, Oid relid) { ! dlist_iter iter; ! dlist_foreach(iter, &saved_plan_list) { + CachedPlanSource *plansource = dlist_container(CachedPlanSource, + node, iter.cur); + Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC); /* No work if it's already invalidated */ *************** PlanCacheRelCallback(Datum arg, Oid reli *** 1742,1766 **** } } } } /* ! * PlanCacheFuncCallback ! * Syscache inval callback function for PROCOID cache * * Invalidate all plans mentioning the object with the specified hash value, * or all plans mentioning any member of this cache if hashvalue == 0. - * - * Note that the coding would support use for multiple caches, but right - * now only user-defined functions are tracked this way. */ static void ! PlanCacheFuncCallback(Datum arg, int cacheid, uint32 hashvalue) { ! CachedPlanSource *plansource; ! for (plansource = first_saved_plan; plansource; plansource = plansource->next_saved) { ListCell *lc; Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC); --- 1819,1861 ---- } } } + + /* Likewise check cached expressions */ + dlist_foreach(iter, &cached_expression_list) + { + CachedExpression *cexpr = dlist_container(CachedExpression, + node, iter.cur); + + Assert(cexpr->magic == CACHEDEXPR_MAGIC); + + /* No work if it's already invalidated */ + if (!cexpr->is_valid) + continue; + + if ((relid == InvalidOid) ? cexpr->relationOids != NIL : + list_member_oid(cexpr->relationOids, relid)) + { + cexpr->is_valid = false; + } + } } /* ! * PlanCacheObjectCallback ! * Syscache inval callback function for PROCOID and TYPEOID caches * * Invalidate all plans mentioning the object with the specified hash value, * or all plans mentioning any member of this cache if hashvalue == 0. */ static void ! PlanCacheObjectCallback(Datum arg, int cacheid, uint32 hashvalue) { ! dlist_iter iter; ! dlist_foreach(iter, &saved_plan_list) { + CachedPlanSource *plansource = dlist_container(CachedPlanSource, + node, iter.cur); ListCell *lc; Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC); *************** PlanCacheFuncCallback(Datum arg, int cac *** 1825,1830 **** --- 1920,1953 ---- } } } + + /* Likewise check cached expressions */ + dlist_foreach(iter, &cached_expression_list) + { + CachedExpression *cexpr = dlist_container(CachedExpression, + node, iter.cur); + ListCell *lc; + + Assert(cexpr->magic == CACHEDEXPR_MAGIC); + + /* No work if it's already invalidated */ + if (!cexpr->is_valid) + continue; + + foreach(lc, cexpr->invalItems) + { + PlanInvalItem *item = (PlanInvalItem *) lfirst(lc); + + if (item->cacheId != cacheid) + continue; + if (hashvalue == 0 || + item->hashValue == hashvalue) + { + cexpr->is_valid = false; + break; + } + } + } } /* *************** PlanCacheSysCallback(Datum arg, int cach *** 1845,1854 **** void ResetPlanCache(void) { ! CachedPlanSource *plansource; ! for (plansource = first_saved_plan; plansource; plansource = plansource->next_saved) { ListCell *lc; Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC); --- 1968,1979 ---- void ResetPlanCache(void) { ! dlist_iter iter; ! dlist_foreach(iter, &saved_plan_list) { + CachedPlanSource *plansource = dlist_container(CachedPlanSource, + node, iter.cur); ListCell *lc; Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC); *************** ResetPlanCache(void) *** 1888,1891 **** --- 2013,2027 ---- } } } + + /* Likewise invalidate cached expressions */ + dlist_foreach(iter, &cached_expression_list) + { + CachedExpression *cexpr = dlist_container(CachedExpression, + node, iter.cur); + + Assert(cexpr->magic == CACHEDEXPR_MAGIC); + + cexpr->is_valid = false; + } } diff --git a/src/backend/utils/cache/typcache.c b/src/backend/utils/cache/typcache.c index 09f9d5f..1a96cc9 100644 *** a/src/backend/utils/cache/typcache.c --- b/src/backend/utils/cache/typcache.c *************** load_domaintype_info(TypeCacheEntry *typ *** 992,998 **** check_expr = (Expr *) stringToNode(constring); ! /* ExecInitExpr will assume we've planned the expression */ check_expr = expression_planner(check_expr); r = makeNode(DomainConstraintState); --- 992,1007 ---- check_expr = (Expr *) stringToNode(constring); ! /* ! * Plan the expression, since ExecInitExpr will expect that. ! * ! * Note: caching the result of expression_planner() is not very ! * good practice. Ideally we'd use a CachedExpression here so ! * that we would react promptly to, eg, changes in inlined ! * functions. However, because we don't support mutable domain ! * CHECK constraints, it's not really clear that it's worth the ! * extra overhead to do that. ! */ check_expr = expression_planner(check_expr); r = makeNode(DomainConstraintState); diff --git a/src/include/optimizer/planmain.h b/src/include/optimizer/planmain.h index c8ab028..2b1932d 100644 *** a/src/include/optimizer/planmain.h --- b/src/include/optimizer/planmain.h *************** extern bool innerrel_is_unique(PlannerIn *** 116,124 **** --- 116,126 ---- */ extern Plan *set_plan_references(PlannerInfo *root, Plan *plan); extern void record_plan_function_dependency(PlannerInfo *root, Oid funcid); + extern void record_plan_type_dependency(PlannerInfo *root, Oid typeid); extern void extract_query_dependencies(Node *query, List **relationOids, List **invalItems, bool *hasRowSecurity); + extern bool extract_query_dependencies_walker(Node *node, PlannerInfo *root); #endif /* PLANMAIN_H */ diff --git a/src/include/optimizer/planner.h b/src/include/optimizer/planner.h index 3e733b3..902ab40 100644 *** a/src/include/optimizer/planner.h --- b/src/include/optimizer/planner.h *************** extern Path *get_cheapest_fractional_pat *** 55,60 **** --- 55,63 ---- double tuple_fraction); extern Expr *expression_planner(Expr *expr); + extern Expr *expression_planner_with_deps(Expr *expr, + List **relationOids, + List **invalItems); extern Expr *preprocess_phv_expression(PlannerInfo *root, Expr *expr); diff --git a/src/include/utils/plancache.h b/src/include/utils/plancache.h index 5fc7903..7fd7ea6 100644 *** a/src/include/utils/plancache.h --- b/src/include/utils/plancache.h *************** *** 16,29 **** --- 16,42 ---- #define PLANCACHE_H #include "access/tupdesc.h" + #include "lib/ilist.h" #include "nodes/params.h" #include "utils/queryenvironment.h" /* Forward declaration, to avoid including parsenodes.h here */ struct RawStmt; + /* possible values for plan_cache_mode */ + typedef enum + { + PLAN_CACHE_MODE_AUTO, + PLAN_CACHE_MODE_FORCE_GENERIC_PLAN, + PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN + } PlanCacheMode; + + /* GUC parameter */ + extern int plan_cache_mode; + #define CACHEDPLANSOURCE_MAGIC 195726186 #define CACHEDPLAN_MAGIC 953717834 + #define CACHEDEXPR_MAGIC 838275847 /* * CachedPlanSource (which might better have been called CachedQuery) *************** typedef struct CachedPlanSource *** 110,116 **** bool is_valid; /* is the query_list currently valid? */ int generation; /* increments each time we create a plan */ /* If CachedPlanSource has been saved, it is a member of a global list */ ! struct CachedPlanSource *next_saved; /* list link, if so */ /* State kept to help decide whether to use custom or generic plans: */ double generic_cost; /* cost of generic plan, or -1 if not known */ double total_custom_cost; /* total cost of custom plans so far */ --- 123,129 ---- bool is_valid; /* is the query_list currently valid? */ int generation; /* increments each time we create a plan */ /* If CachedPlanSource has been saved, it is a member of a global list */ ! dlist_node node; /* list link, if is_saved */ /* State kept to help decide whether to use custom or generic plans: */ double generic_cost; /* cost of generic plan, or -1 if not known */ double total_custom_cost; /* total cost of custom plans so far */ *************** typedef struct CachedPlan *** 143,148 **** --- 156,185 ---- MemoryContext context; /* context containing this CachedPlan */ } CachedPlan; + /* + * CachedExpression is a low-overhead mechanism for caching the planned form + * of standalone scalar expressions. While such expressions are not usually + * subject to cache invalidation events, that can happen, for example because + * of replacement of a SQL function that was inlined into the expression. + * The plancache takes care of storing the expression tree and marking it + * invalid if a cache invalidation occurs, but the caller must notice the + * !is_valid status and discard the obsolete expression without reusing it. + * We do not store the original parse tree, only the planned expression; + * this is an optimization based on the assumption that we usually will not + * need to replan for the life of the session. + */ + typedef struct CachedExpression + { + int magic; /* should equal CACHEDEXPR_MAGIC */ + Node *expr; /* planned form of expression */ + bool is_valid; /* is the expression still valid? */ + /* remaining fields should be treated as private to plancache.c: */ + List *relationOids; /* OIDs of relations the expr depends on */ + List *invalItems; /* other dependencies, as PlanInvalItems */ + MemoryContext context; /* context containing this CachedExpression */ + dlist_node node; /* link in global list of CachedExpressions */ + } CachedExpression; + extern void InitPlanCache(void); extern void ResetPlanCache(void); *************** extern CachedPlan *GetCachedPlan(CachedP *** 182,196 **** QueryEnvironment *queryEnv); extern void ReleaseCachedPlan(CachedPlan *plan, bool useResOwner); ! /* possible values for plan_cache_mode */ ! typedef enum ! { ! PLAN_CACHE_MODE_AUTO, ! PLAN_CACHE_MODE_FORCE_GENERIC_PLAN, ! PLAN_CACHE_MODE_FORCE_CUSTOM_PLAN ! } PlanCacheMode; ! ! /* GUC parameter */ ! extern int plan_cache_mode; #endif /* PLANCACHE_H */ --- 219,225 ---- QueryEnvironment *queryEnv); extern void ReleaseCachedPlan(CachedPlan *plan, bool useResOwner); ! extern CachedExpression *GetCachedExpression(Node *expr); ! extern void FreeCachedExpression(CachedExpression *cexpr); #endif /* PLANCACHE_H */ diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c index 39ea925..9078bc1 100644 *** a/src/pl/plpgsql/src/pl_exec.c --- b/src/pl/plpgsql/src/pl_exec.c *************** typedef struct /* cast_hash table en *** 152,157 **** --- 152,158 ---- { plpgsql_CastHashKey key; /* hash key --- MUST BE FIRST */ Expr *cast_expr; /* cast expression, or NULL if no-op cast */ + CachedExpression *cast_cexpr; /* cached expression backing the above */ /* ExprState is valid only when cast_lxid matches current LXID */ ExprState *cast_exprstate; /* expression's eval tree */ bool cast_in_use; /* true while we're executing eval tree */ *************** get_cast_hashentry(PLpgSQL_execstate *es *** 7610,7627 **** cast_key.dsttypmod = dsttypmod; cast_entry = (plpgsql_CastHashEntry *) hash_search(estate->cast_hash, (void *) &cast_key, ! HASH_FIND, NULL); ! if (cast_entry == NULL) { ! /* We've not looked up this coercion before */ Node *cast_expr; CaseTestExpr *placeholder; /* * Since we could easily fail (no such coercion), construct a * temporary coercion expression tree in the short-lived ! * eval_mcontext, then if successful copy it to cast_hash_context. */ oldcontext = MemoryContextSwitchTo(get_eval_mcontext(estate)); --- 7611,7644 ---- cast_key.dsttypmod = dsttypmod; cast_entry = (plpgsql_CastHashEntry *) hash_search(estate->cast_hash, (void *) &cast_key, ! HASH_ENTER, &found); ! if (!found) /* initialize if new entry */ ! cast_entry->cast_cexpr = NULL; ! if (cast_entry->cast_cexpr == NULL || ! !cast_entry->cast_cexpr->is_valid) { ! /* ! * We've not looked up this coercion before, or we have but the cached ! * expression has been invalidated. ! */ Node *cast_expr; + CachedExpression *cast_cexpr; CaseTestExpr *placeholder; /* + * Drop old cached expression if there is one. + */ + if (cast_entry->cast_cexpr) + { + FreeCachedExpression(cast_entry->cast_cexpr); + cast_entry->cast_cexpr = NULL; + } + + /* * Since we could easily fail (no such coercion), construct a * temporary coercion expression tree in the short-lived ! * eval_mcontext, then if successful save it as a CachedExpression. */ oldcontext = MemoryContextSwitchTo(get_eval_mcontext(estate)); *************** get_cast_hashentry(PLpgSQL_execstate *es *** 7682,7714 **** /* Note: we don't bother labeling the expression tree with collation */ /* Detect whether we have a no-op (RelabelType) coercion */ if (IsA(cast_expr, RelabelType) && ((RelabelType *) cast_expr)->arg == (Expr *) placeholder) cast_expr = NULL; ! if (cast_expr) ! { ! /* ExecInitExpr assumes we've planned the expression */ ! cast_expr = (Node *) expression_planner((Expr *) cast_expr); ! ! /* Now copy the tree into cast_hash_context */ ! MemoryContextSwitchTo(estate->cast_hash_context); ! ! cast_expr = copyObject(cast_expr); ! } ! ! MemoryContextSwitchTo(oldcontext); ! ! /* Now we can fill in a hashtable entry. */ ! cast_entry = (plpgsql_CastHashEntry *) hash_search(estate->cast_hash, ! (void *) &cast_key, ! HASH_ENTER, &found); ! Assert(!found); /* wasn't there a moment ago */ cast_entry->cast_expr = (Expr *) cast_expr; cast_entry->cast_exprstate = NULL; cast_entry->cast_in_use = false; cast_entry->cast_lxid = InvalidLocalTransactionId; } /* Done if we have determined that this is a no-op cast. */ --- 7699,7721 ---- /* Note: we don't bother labeling the expression tree with collation */ + /* Plan the expression and build a CachedExpression */ + cast_cexpr = GetCachedExpression(cast_expr); + cast_expr = cast_cexpr->expr; + /* Detect whether we have a no-op (RelabelType) coercion */ if (IsA(cast_expr, RelabelType) && ((RelabelType *) cast_expr)->arg == (Expr *) placeholder) cast_expr = NULL; ! /* Now we can fill in the hashtable entry. */ ! cast_entry->cast_cexpr = cast_cexpr; cast_entry->cast_expr = (Expr *) cast_expr; cast_entry->cast_exprstate = NULL; cast_entry->cast_in_use = false; cast_entry->cast_lxid = InvalidLocalTransactionId; + + MemoryContextSwitchTo(oldcontext); } /* Done if we have determined that this is a no-op cast. */ diff --git a/src/test/regress/expected/domain.out b/src/test/regress/expected/domain.out index 0b5a904..11bc772 100644 *** a/src/test/regress/expected/domain.out --- b/src/test/regress/expected/domain.out *************** create domain di as int; *** 1020,1025 **** --- 1020,1050 ---- create function dom_check(int) returns di as $$ declare d di; begin + d := $1::di; + return d; + end + $$ language plpgsql immutable; + select dom_check(0); + dom_check + ----------- + 0 + (1 row) + + alter domain di add constraint pos check (value > 0); + select dom_check(0); -- fail + ERROR: value for domain di violates check constraint "pos" + CONTEXT: PL/pgSQL function dom_check(integer) line 4 at assignment + alter domain di drop constraint pos; + select dom_check(0); + dom_check + ----------- + 0 + (1 row) + + -- implicit cast during assignment is a separate code path, test that too + create or replace function dom_check(int) returns di as $$ + declare d di; + begin d := $1; return d; end diff --git a/src/test/regress/sql/domain.sql b/src/test/regress/sql/domain.sql index 68da27d..1291d55 100644 *** a/src/test/regress/sql/domain.sql --- b/src/test/regress/sql/domain.sql *************** create domain di as int; *** 680,685 **** --- 680,705 ---- create function dom_check(int) returns di as $$ declare d di; begin + d := $1::di; + return d; + end + $$ language plpgsql immutable; + + select dom_check(0); + + alter domain di add constraint pos check (value > 0); + + select dom_check(0); -- fail + + alter domain di drop constraint pos; + + select dom_check(0); + + -- implicit cast during assignment is a separate code path, test that too + + create or replace function dom_check(int) returns di as $$ + declare d di; + begin d := $1; return d; end