diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c index 416a2c4f3bbe2132ed6d66f6eeaee9067e915d9b..cb5b84509ce8a89dfa8bf309c9c64ffdfdffe43d 100644 *** a/src/backend/executor/spi.c --- b/src/backend/executor/spi.c *************** static int _SPI_curid = -1; *** 49,56 **** static Portal SPI_cursor_open_internal(const char *name, SPIPlanPtr plan, ParamListInfo paramLI, bool read_only); ! static void _SPI_prepare_plan(const char *src, SPIPlanPtr plan, ! ParamListInfo boundParams); static int _SPI_execute_plan(SPIPlanPtr plan, ParamListInfo paramLI, Snapshot snapshot, Snapshot crosscheck_snapshot, --- 49,57 ---- static Portal SPI_cursor_open_internal(const char *name, SPIPlanPtr plan, ParamListInfo paramLI, bool read_only); ! static void _SPI_prepare_plan(const char *src, SPIPlanPtr plan); ! ! static void _SPI_prepare_oneshot_plan(const char *src, SPIPlanPtr plan); static int _SPI_execute_plan(SPIPlanPtr plan, ParamListInfo paramLI, Snapshot snapshot, Snapshot crosscheck_snapshot, *************** SPI_execute(const char *src, bool read_o *** 355,361 **** plan.magic = _SPI_PLAN_MAGIC; plan.cursor_options = 0; ! _SPI_prepare_plan(src, &plan, NULL); res = _SPI_execute_plan(&plan, NULL, InvalidSnapshot, InvalidSnapshot, --- 356,362 ---- plan.magic = _SPI_PLAN_MAGIC; plan.cursor_options = 0; ! _SPI_prepare_oneshot_plan(src, &plan); res = _SPI_execute_plan(&plan, NULL, InvalidSnapshot, InvalidSnapshot, *************** SPI_execute_with_args(const char *src, *** 506,512 **** paramLI = _SPI_convert_params(nargs, argtypes, Values, Nulls); ! _SPI_prepare_plan(src, &plan, paramLI); res = _SPI_execute_plan(&plan, paramLI, InvalidSnapshot, InvalidSnapshot, --- 507,513 ---- paramLI = _SPI_convert_params(nargs, argtypes, Values, Nulls); ! _SPI_prepare_oneshot_plan(src, &plan); res = _SPI_execute_plan(&plan, paramLI, InvalidSnapshot, InvalidSnapshot, *************** SPI_prepare_cursor(const char *src, int *** 547,553 **** plan.parserSetup = NULL; plan.parserSetupArg = NULL; ! _SPI_prepare_plan(src, &plan, NULL); /* copy plan to procedure context */ result = _SPI_make_plan_non_temp(&plan); --- 548,554 ---- plan.parserSetup = NULL; plan.parserSetupArg = NULL; ! _SPI_prepare_plan(src, &plan); /* copy plan to procedure context */ result = _SPI_make_plan_non_temp(&plan); *************** SPI_prepare_params(const char *src, *** 584,590 **** plan.parserSetup = parserSetup; plan.parserSetupArg = parserSetupArg; ! _SPI_prepare_plan(src, &plan, NULL); /* copy plan to procedure context */ result = _SPI_make_plan_non_temp(&plan); --- 585,591 ---- plan.parserSetup = parserSetup; plan.parserSetupArg = parserSetupArg; ! _SPI_prepare_plan(src, &plan); /* copy plan to procedure context */ result = _SPI_make_plan_non_temp(&plan); *************** SPI_keepplan(SPIPlanPtr plan) *** 599,605 **** { ListCell *lc; ! if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC || plan->saved) return SPI_ERROR_ARGUMENT; /* --- 600,607 ---- { ListCell *lc; ! if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC || ! plan->saved || plan->oneshot) return SPI_ERROR_ARGUMENT; /* *************** SPI_cursor_open_with_args(const char *na *** 1083,1089 **** paramLI = _SPI_convert_params(nargs, argtypes, Values, Nulls); ! _SPI_prepare_plan(src, &plan, paramLI); /* We needn't copy the plan; SPI_cursor_open_internal will do so */ --- 1085,1091 ---- paramLI = _SPI_convert_params(nargs, argtypes, Values, Nulls); ! _SPI_prepare_plan(src, &plan); /* We needn't copy the plan; SPI_cursor_open_internal will do so */ *************** spi_printtup(TupleTableSlot *slot, DestR *** 1645,1654 **** * * At entry, plan->argtypes and plan->nargs (or alternatively plan->parserSetup * and plan->parserSetupArg) must be valid, as must plan->cursor_options. - * If boundParams isn't NULL then it represents parameter values that are made - * available to the planner (as either estimates or hard values depending on - * their PARAM_FLAG_CONST marking). The boundParams had better match the - * param type information embedded in the plan! * * Results are stored into *plan (specifically, plan->plancache_list). * Note that the result data is all in CurrentMemoryContext or child contexts --- 1647,1652 ---- *************** spi_printtup(TupleTableSlot *slot, DestR *** 1657,1669 **** * parsing is also left in CurrentMemoryContext. */ static void ! _SPI_prepare_plan(const char *src, SPIPlanPtr plan, ParamListInfo boundParams) { List *raw_parsetree_list; List *plancache_list; ListCell *list_item; ErrorContextCallback spierrcontext; - int cursor_options = plan->cursor_options; /* * Setup error traceback support for ereport() --- 1655,1666 ---- * parsing is also left in CurrentMemoryContext. */ static void ! _SPI_prepare_plan(const char *src, SPIPlanPtr plan) { List *raw_parsetree_list; List *plancache_list; ListCell *list_item; ErrorContextCallback spierrcontext; /* * Setup error traceback support for ereport() *************** _SPI_prepare_plan(const char *src, SPIPl *** 1726,1738 **** plan->nargs, plan->parserSetup, plan->parserSetupArg, ! cursor_options, false); /* not fixed result */ plancache_list = lappend(plancache_list, plansource); } plan->plancache_list = plancache_list; /* * Pop the error context stack --- 1723,1802 ---- plan->nargs, plan->parserSetup, plan->parserSetupArg, ! plan->cursor_options, false); /* not fixed result */ plancache_list = lappend(plancache_list, plansource); } plan->plancache_list = plancache_list; + plan->oneshot = false; + + /* + * Pop the error context stack + */ + error_context_stack = spierrcontext.previous; + } + + /* + * Parse, but don't analyze, a querystring. + * + * This is a stripped-down version of _SPI_prepare_plan that only does the + * initial raw parsing. It creates "one shot" CachedPlanSources + * that still require parse analysis before execution is possible. + * + * The advantage of using the "one shot" form of CachedPlanSource is that + * we eliminate data copying and invalidation overhead. Postponing parse + * analysis also prevents issues if some of the raw parsetrees are DDL + * commands that affect validity of later parsetrees. Both of these + * attributes are good things for SPI_execute() and similar cases. + * + * Results are stored into *plan (specifically, plan->plancache_list). + * Note that the result data is all in CurrentMemoryContext or child contexts + * thereof; in practice this means it is in the SPI executor context, and + * what we are creating is a "temporary" SPIPlan. Cruft generated during + * parsing is also left in CurrentMemoryContext. + */ + static void + _SPI_prepare_oneshot_plan(const char *src, SPIPlanPtr plan) + { + List *raw_parsetree_list; + List *plancache_list; + ListCell *list_item; + ErrorContextCallback spierrcontext; + + /* + * Setup error traceback support for ereport() + */ + spierrcontext.callback = _SPI_error_callback; + spierrcontext.arg = (void *) src; + spierrcontext.previous = error_context_stack; + error_context_stack = &spierrcontext; + + /* + * Parse the request string into a list of raw parse trees. + */ + raw_parsetree_list = pg_parse_query(src); + + /* + * Construct plancache entries, but don't do parse analysis yet. + */ + plancache_list = NIL; + + foreach(list_item, raw_parsetree_list) + { + Node *parsetree = (Node *) lfirst(list_item); + CachedPlanSource *plansource; + + plansource = CreateOneShotCachedPlan(parsetree, + src, + CreateCommandTag(parsetree)); + + plancache_list = lappend(plancache_list, plansource); + } + + plan->plancache_list = plancache_list; + plan->oneshot = true; /* * Pop the error context stack *************** _SPI_execute_plan(SPIPlanPtr plan, Param *** 1770,1776 **** * Setup error traceback support for ereport() */ spierrcontext.callback = _SPI_error_callback; ! spierrcontext.arg = NULL; spierrcontext.previous = error_context_stack; error_context_stack = &spierrcontext; --- 1834,1840 ---- * Setup error traceback support for ereport() */ spierrcontext.callback = _SPI_error_callback; ! spierrcontext.arg = NULL; /* we'll fill this below */ spierrcontext.previous = error_context_stack; error_context_stack = &spierrcontext; *************** _SPI_execute_plan(SPIPlanPtr plan, Param *** 1817,1822 **** --- 1881,1927 ---- spierrcontext.arg = (void *) plansource->query_string; /* + * If this is a one-shot plan, we still need to do parse analysis. + */ + if (plan->oneshot) + { + Node *parsetree = plansource->raw_parse_tree; + const char *src = plansource->query_string; + List *stmt_list; + + /* + * Parameter datatypes are driven by parserSetup hook if provided, + * otherwise we use the fixed parameter list. + */ + if (plan->parserSetup != NULL) + { + Assert(plan->nargs == 0); + stmt_list = pg_analyze_and_rewrite_params(parsetree, + src, + plan->parserSetup, + plan->parserSetupArg); + } + else + { + stmt_list = pg_analyze_and_rewrite(parsetree, + src, + plan->argtypes, + plan->nargs); + } + + /* Finish filling in the CachedPlanSource */ + CompleteCachedPlan(plansource, + stmt_list, + NULL, + plan->argtypes, + plan->nargs, + plan->parserSetup, + plan->parserSetupArg, + plan->cursor_options, + false); /* not fixed result */ + } + + /* * Replan if needed, and increment plan refcount. If it's a saved * plan, the refcount must be backed by the CurrentResourceOwner. */ *************** _SPI_make_plan_non_temp(SPIPlanPtr plan) *** 2313,2318 **** --- 2418,2425 ---- /* Assert the input is a temporary SPIPlan */ Assert(plan->magic == _SPI_PLAN_MAGIC); Assert(plan->plancxt == NULL); + /* One-shot plans can't be saved */ + Assert(!plan->oneshot); /* * Create a memory context for the plan, underneath the procedure context. *************** _SPI_make_plan_non_temp(SPIPlanPtr plan) *** 2330,2335 **** --- 2437,2443 ---- newplan = (SPIPlanPtr) palloc(sizeof(_SPI_plan)); newplan->magic = _SPI_PLAN_MAGIC; newplan->saved = false; + newplan->oneshot = false; newplan->plancache_list = NIL; newplan->plancxt = plancxt; newplan->cursor_options = plan->cursor_options; *************** _SPI_save_plan(SPIPlanPtr plan) *** 2379,2384 **** --- 2487,2495 ---- MemoryContext oldcxt; ListCell *lc; + /* One-shot plans can't be saved */ + Assert(!plan->oneshot); + /* * Create a memory context for the plan. We don't expect the plan to be * very large, so use smaller-than-default alloc parameters. It's a *************** _SPI_save_plan(SPIPlanPtr plan) *** 2395,2400 **** --- 2506,2512 ---- newplan = (SPIPlanPtr) palloc(sizeof(_SPI_plan)); newplan->magic = _SPI_PLAN_MAGIC; newplan->saved = false; + newplan->oneshot = false; newplan->plancache_list = NIL; newplan->plancxt = plancxt; newplan->cursor_options = plan->cursor_options; diff --git a/src/backend/utils/cache/plancache.c b/src/backend/utils/cache/plancache.c index 8c0391ffcbdfa9058c345930c6d9568dbc9c526d..a211869866674ffbf06393d29a742cf5c69a7639 100644 *** a/src/backend/utils/cache/plancache.c --- b/src/backend/utils/cache/plancache.c *************** CreateCachedPlan(Node *raw_parse_tree, *** 181,186 **** --- 181,187 ---- plansource->invalItems = NIL; plansource->query_context = NULL; plansource->gplan = NULL; + plansource->is_oneshot = false; plansource->is_complete = false; plansource->is_saved = false; plansource->is_valid = false; *************** CreateCachedPlan(Node *raw_parse_tree, *** 196,201 **** --- 197,265 ---- } /* + * CreateOneShotCachedPlan: initially create a one-shot plan cache entry. + * + * This variant of CreateCachedPlan creates a plan cache entry that is meant + * to be used only once. No data copying occurs: all data structures remain + * in the caller's memory context (which typically should get cleared after + * completing execution). The CachedPlanSource struct itself is also created + * in that context. + * + * A one-shot plan cannot be saved or copied, since we make no effort to + * preserve the raw parse tree unmodified. There is also no support for + * invalidation, so plan use must be completed in the current transaction, + * and DDL that might invalidate the querytree_list must be avoided as well. + * + * raw_parse_tree: output of raw_parser() + * query_string: original query text + * commandTag: compile-time-constant tag for query, or NULL if empty query + */ + CachedPlanSource * + CreateOneShotCachedPlan(Node *raw_parse_tree, + const char *query_string, + const char *commandTag) + { + CachedPlanSource *plansource; + + Assert(query_string != NULL); /* required as of 8.4 */ + + /* + * Create and fill the CachedPlanSource struct within the caller's memory + * context. Most fields are just left empty for the moment. + */ + plansource = (CachedPlanSource *) palloc0(sizeof(CachedPlanSource)); + plansource->magic = CACHEDPLANSOURCE_MAGIC; + plansource->raw_parse_tree = raw_parse_tree; + plansource->query_string = query_string; + plansource->commandTag = commandTag; + plansource->param_types = NULL; + plansource->num_params = 0; + plansource->parserSetup = NULL; + plansource->parserSetupArg = NULL; + plansource->cursor_options = 0; + plansource->fixed_result = false; + plansource->resultDesc = NULL; + plansource->search_path = NULL; + plansource->context = CurrentMemoryContext; + plansource->query_list = NIL; + plansource->relationOids = NIL; + plansource->invalItems = NIL; + plansource->query_context = NULL; + plansource->gplan = NULL; + plansource->is_oneshot = true; + plansource->is_complete = false; + 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; + + return plansource; + } + + /* * CompleteCachedPlan: second step of creating a plan cache entry. * * Pass in the analyzed-and-rewritten form of the query, as well as the *************** CreateCachedPlan(Node *raw_parse_tree, *** 222,227 **** --- 286,295 ---- * option, it is caller's responsibility that the referenced data remains * valid for as long as the CachedPlanSource exists. * + * If the CachedPlanSource is a "oneshot" plan, then no querytree copying + * occurs at all, and querytree_context is ignored; it is caller's + * responsibility that the passed querytree_list is sufficiently long-lived. + * * plansource: structure returned by CreateCachedPlan * querytree_list: analyzed-and-rewritten form of query (list of Query nodes) * querytree_context: memory context containing querytree_list, *************** CompleteCachedPlan(CachedPlanSource *pla *** 254,262 **** /* * If caller supplied a querytree_context, reparent it underneath the * CachedPlanSource's context; otherwise, create a suitable context and ! * copy the querytree_list into it. */ ! if (querytree_context != NULL) { MemoryContextSetParent(querytree_context, source_context); MemoryContextSwitchTo(querytree_context); --- 322,336 ---- /* * If caller supplied a querytree_context, reparent it underneath the * CachedPlanSource's context; otherwise, create a suitable context and ! * copy the querytree_list into it. But no data copying should be done ! * for one-shot plans; for those, assume the passed querytree_list is ! * sufficiently long-lived. */ ! if (plansource->is_oneshot) ! { ! querytree_context = CurrentMemoryContext; ! } ! else if (querytree_context != NULL) { MemoryContextSetParent(querytree_context, source_context); MemoryContextSwitchTo(querytree_context); *************** CompleteCachedPlan(CachedPlanSource *pla *** 279,289 **** /* * Use the planner machinery to extract dependencies. Data is saved in * query_context. (We assume that not a lot of extra cruft is created by ! * this call.) */ ! extract_query_dependencies((Node *) querytree_list, ! &plansource->relationOids, ! &plansource->invalItems); /* * Save the final parameter types (or other parameter specification data) --- 353,364 ---- /* * Use the planner machinery to extract dependencies. Data is saved in * query_context. (We assume that not a lot of extra cruft is created by ! * this call.) We can skip this for one-shot plans. */ ! if (!plansource->is_oneshot) ! extract_query_dependencies((Node *) querytree_list, ! &plansource->relationOids, ! &plansource->invalItems); /* * Save the final parameter types (or other parameter specification data) *************** CompleteCachedPlan(CachedPlanSource *pla *** 326,332 **** * it to the list of cached plans that are checked for invalidation when an * sinval event occurs. * ! * This is guaranteed not to throw error; callers typically depend on that * since this is called just before or just after adding a pointer to the * CachedPlanSource to some permanent data structure of their own. Up until * this is done, a CachedPlanSource is just transient data that will go away --- 401,408 ---- * it to the list of cached plans that are checked for invalidation when an * sinval event occurs. * ! * This is guaranteed not to throw error, except for the caller-error case ! * of trying to save a one-shot plan. Callers typically depend on that * since this is called just before or just after adding a pointer to the * CachedPlanSource to some permanent data structure of their own. Up until * this is done, a CachedPlanSource is just transient data that will go away *************** SaveCachedPlan(CachedPlanSource *plansou *** 340,345 **** --- 416,425 ---- Assert(plansource->is_complete); Assert(!plansource->is_saved); + /* This seems worth a real test, though */ + if (plansource->is_oneshot) + elog(ERROR, "cannot save one-shot cached plan"); + /* * In typical use, this function would be called before generating any * plans from the CachedPlanSource. If there is a generic plan, moving it *************** DropCachedPlan(CachedPlanSource *plansou *** 402,412 **** /* Decrement generic CachePlan's refcount and drop if no longer needed */ ReleaseGenericPlan(plansource); /* * Remove the CachedPlanSource and all subsidiary data (including the ! * query_context if any). */ ! MemoryContextDelete(plansource->context); } /* --- 482,496 ---- /* Decrement generic CachePlan's refcount and drop if no longer needed */ ReleaseGenericPlan(plansource); + /* Mark it no longer valid */ + plansource->magic = 0; + /* * Remove the CachedPlanSource and all subsidiary data (including the ! * query_context if any). But if it's a one-shot we can't free anything. */ ! if (!plansource->is_oneshot) ! MemoryContextDelete(plansource->context); } /* *************** RevalidateCachedQuery(CachedPlanSource * *** 452,457 **** --- 536,552 ---- MemoryContext oldcxt; /* + * For one-shot plans, we do not support revalidation checking; it's + * assumed the query is parsed, planned, and executed in one transaction, + * so that no lock re-acquisition is necessary. + */ + if (plansource->is_oneshot) + { + Assert(plansource->is_valid); + return NIL; + } + + /* * If the query is currently valid, acquire locks on the referenced * objects; then check again. We need to do it this way to cover the race * condition that an invalidation message arrives before we get the locks. *************** CheckCachedPlan(CachedPlanSource *planso *** 649,654 **** --- 744,751 ---- return false; Assert(plan->magic == CACHEDPLAN_MAGIC); + /* Generic plans are never one-shot */ + Assert(!plan->is_oneshot); /* * If it appears valid, acquire locks and recheck; this is much the same *************** CheckCachedPlan(CachedPlanSource *planso *** 708,714 **** * hint rather than a hard constant. * * Planning work is done in the caller's memory context. The finished plan ! * is in a child memory context, which typically should get reparented. */ static CachedPlan * BuildCachedPlan(CachedPlanSource *plansource, List *qlist, --- 805,812 ---- * hint rather than a hard constant. * * Planning work is done in the caller's memory context. The finished plan ! * is in a child memory context, which typically should get reparented ! * (unless this is a one-shot plan, in which case we don't copy the plan). */ static CachedPlan * BuildCachedPlan(CachedPlanSource *plansource, List *qlist, *************** BuildCachedPlan(CachedPlanSource *planso *** 719,725 **** bool snapshot_set; bool spi_pushed; MemoryContext plan_context; ! MemoryContext oldcxt; /* * Normally the querytree should be valid already, but if it's not, --- 817,823 ---- bool snapshot_set; bool spi_pushed; MemoryContext plan_context; ! MemoryContext oldcxt = CurrentMemoryContext; /* * Normally the querytree should be valid already, but if it's not, *************** BuildCachedPlan(CachedPlanSource *planso *** 739,748 **** /* * If we don't already have a copy of the querytree list that can be ! * scribbled on by the planner, make one. */ if (qlist == NIL) ! qlist = (List *) copyObject(plansource->query_list); /* * Restore the search_path that was in use when the plan was made. See --- 837,852 ---- /* * If we don't already have a copy of the querytree list that can be ! * scribbled on by the planner, make one. For a one-shot plan, we assume ! * it's okay to scribble on the original query_list. */ if (qlist == NIL) ! { ! if (!plansource->is_oneshot) ! qlist = (List *) copyObject(plansource->query_list); ! else ! qlist = plansource->query_list; ! } /* * Restore the search_path that was in use when the plan was made. See *************** BuildCachedPlan(CachedPlanSource *planso *** 794,815 **** PopOverrideSearchPath(); /* ! * Make a dedicated memory context for the CachedPlan and its subsidiary ! * data. It's probably not going to be large, but just in case, use the ! * default maxsize parameter. It's transient for the moment. */ ! plan_context = AllocSetContextCreate(CurrentMemoryContext, ! "CachedPlan", ! ALLOCSET_SMALL_MINSIZE, ! ALLOCSET_SMALL_INITSIZE, ! ALLOCSET_DEFAULT_MAXSIZE); ! /* ! * Copy plan into the new context. ! */ ! oldcxt = MemoryContextSwitchTo(plan_context); ! plist = (List *) copyObject(plist); /* * Create and fill the CachedPlan struct within the new context. --- 898,926 ---- PopOverrideSearchPath(); /* ! * Normally we make a dedicated memory context for the CachedPlan and its ! * subsidiary data. (It's probably not going to be large, but just in ! * case, use the default maxsize parameter. It's transient for the ! * moment.) But for a one-shot plan, we just leave it in the caller's ! * memory context. */ ! if (!plansource->is_oneshot) ! { ! plan_context = AllocSetContextCreate(CurrentMemoryContext, ! "CachedPlan", ! ALLOCSET_SMALL_MINSIZE, ! ALLOCSET_SMALL_INITSIZE, ! ALLOCSET_DEFAULT_MAXSIZE); ! /* ! * Copy plan into the new context. ! */ ! MemoryContextSwitchTo(plan_context); ! plist = (List *) copyObject(plist); ! } ! else ! plan_context = CurrentMemoryContext; /* * Create and fill the CachedPlan struct within the new context. *************** BuildCachedPlan(CachedPlanSource *planso *** 826,831 **** --- 937,943 ---- plan->saved_xmin = InvalidTransactionId; plan->refcount = 0; plan->context = plan_context; + plan->is_oneshot = plansource->is_oneshot; plan->is_saved = false; plan->is_valid = true; *************** choose_custom_plan(CachedPlanSource *pla *** 847,853 **** { double avg_custom_cost; ! /* Never any point in a custom plan if there's no parameters */ if (boundParams == NULL) return false; --- 959,969 ---- { double avg_custom_cost; ! /* One-shot plans will always be considered custom */ ! if (plansource->is_oneshot) ! return true; ! ! /* Otherwise, never any point in a custom plan if there's no parameters */ if (boundParams == NULL) return false; *************** ReleaseCachedPlan(CachedPlan *plan, bool *** 1049,1055 **** Assert(plan->refcount > 0); plan->refcount--; if (plan->refcount == 0) ! MemoryContextDelete(plan->context); } /* --- 1165,1178 ---- Assert(plan->refcount > 0); plan->refcount--; if (plan->refcount == 0) ! { ! /* Mark it no longer valid */ ! plan->magic = 0; ! ! /* One-shot plans do not own their context, so we can't free them */ ! if (!plan->is_oneshot) ! MemoryContextDelete(plan->context); ! } } /* *************** CachedPlanSetParentContext(CachedPlanSou *** 1066,1074 **** Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC); Assert(plansource->is_complete); ! /* This seems worth a real test, though */ if (plansource->is_saved) elog(ERROR, "cannot move a saved cached plan to another context"); /* OK, let the caller keep the plan where he wishes */ MemoryContextSetParent(plansource->context, newcontext); --- 1189,1199 ---- Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC); Assert(plansource->is_complete); ! /* These seem worth real tests, though */ if (plansource->is_saved) elog(ERROR, "cannot move a saved cached plan to another context"); + if (plansource->is_oneshot) + elog(ERROR, "cannot move a one-shot cached plan to another context"); /* OK, let the caller keep the plan where he wishes */ MemoryContextSetParent(plansource->context, newcontext); *************** CopyCachedPlan(CachedPlanSource *plansou *** 1105,1110 **** --- 1230,1242 ---- Assert(plansource->magic == CACHEDPLANSOURCE_MAGIC); Assert(plansource->is_complete); + /* + * One-shot plans can't be copied, because we haven't taken care that + * parsing/planning didn't scribble on the raw parse tree or querytrees. + */ + if (plansource->is_oneshot) + elog(ERROR, "cannot copy a one-shot cached plan"); + source_context = AllocSetContextCreate(CurrentMemoryContext, "CachedPlanSource", ALLOCSET_SMALL_MINSIZE, *************** CopyCachedPlan(CachedPlanSource *plansou *** 1152,1157 **** --- 1284,1290 ---- newsource->gplan = NULL; + newsource->is_oneshot = false; newsource->is_complete = true; newsource->is_saved = false; newsource->is_valid = plansource->is_valid; diff --git a/src/include/executor/spi_priv.h b/src/include/executor/spi_priv.h index 4fbb548af4b93d360b6cd48f8f03993bd383594f..1a828912fcddaa89d02a5faf5b837a6d037f679c 100644 *** a/src/include/executor/spi_priv.h --- b/src/include/executor/spi_priv.h *************** typedef struct *** 59,64 **** --- 59,70 ---- * while additional data such as argtypes and list cells is loose in the SPI * executor context. Such plans can be identified by having plancxt == NULL. * + * We can also have "one-shot" SPI plans (which are typically temporary, + * as described above). These are meant to be executed once and discarded, + * and various optimizations are made on the assumption of single use. + * Note in particular that the CachedPlanSources within such an SPI plan + * are not "complete" until execution. + * * Note: if the original query string contained only whitespace and comments, * the plancache_list will be NIL and so there is no place to store the * query string. We don't care about that, but we do care about the *************** typedef struct _SPI_plan *** 68,73 **** --- 74,80 ---- { int magic; /* should equal _SPI_PLAN_MAGIC */ bool saved; /* saved or unsaved plan? */ + bool oneshot; /* one-shot plan? */ List *plancache_list; /* one CachedPlanSource per parsetree */ MemoryContext plancxt; /* Context containing _SPI_plan and data */ int cursor_options; /* Cursor options used for planning */ diff --git a/src/include/utils/plancache.h b/src/include/utils/plancache.h index 413e8462a6c6e50241574d6ebcb2f38837b0af25..7d0fd6e4d2a6c6695b79e3a9efcbc7ee9d749122 100644 *** a/src/include/utils/plancache.h --- b/src/include/utils/plancache.h *************** *** 60,65 **** --- 60,73 ---- * context that holds the rewritten query tree and associated data. This * allows the query tree to be discarded easily when it is invalidated. * + * Some callers wish to use the CachedPlan API even with one-shot queries + * that have no reason to be saved at all. We therefore support a "oneshot" + * variant that does no data copying or invalidation checking. In this case + * there are no separate memory contexts: the CachedPlanSource struct and + * all subsidiary data live in the caller's CurrentMemoryContext, and there + * is no way to free memory short of clearing that entire context. A oneshot + * plan is always treated as unsaved. + * * Note: the string referenced by commandTag is not subsidiary storage; * it is assumed to be a compile-time-constant string. As with portals, * commandTag shall be NULL if and only if the original query string (before *************** typedef struct CachedPlanSource *** 69,75 **** { int magic; /* should equal CACHEDPLANSOURCE_MAGIC */ Node *raw_parse_tree; /* output of raw_parser() */ ! char *query_string; /* source text of query */ const char *commandTag; /* command tag (a constant!), or NULL */ Oid *param_types; /* array of parameter type OIDs, or NULL */ int num_params; /* length of param_types array */ --- 77,83 ---- { int magic; /* should equal CACHEDPLANSOURCE_MAGIC */ Node *raw_parse_tree; /* output of raw_parser() */ ! const char *query_string; /* source text of query */ const char *commandTag; /* command tag (a constant!), or NULL */ Oid *param_types; /* array of parameter type OIDs, or NULL */ int num_params; /* length of param_types array */ *************** typedef struct CachedPlanSource *** 88,93 **** --- 96,102 ---- /* If we have a generic plan, this is a reference-counted link to it: */ struct CachedPlan *gplan; /* generic plan, or NULL if not valid */ /* Some state flags: */ + bool is_oneshot; /* is it a "oneshot" plan? */ bool is_complete; /* has CompleteCachedPlan been done? */ bool is_saved; /* has CachedPlanSource been "saved"? */ bool is_valid; /* is the query_list currently valid? */ *************** typedef struct CachedPlanSource *** 106,118 **** * (if any), and any active plan executions, so the plan can be discarded * exactly when refcount goes to zero. Both the struct itself and the * subsidiary data live in the context denoted by the context field. ! * This makes it easy to free a no-longer-needed cached plan. */ typedef struct CachedPlan { int magic; /* should equal CACHEDPLAN_MAGIC */ List *stmt_list; /* list of statement nodes (PlannedStmts and * bare utility statements) */ bool is_saved; /* is CachedPlan in a long-lived context? */ bool is_valid; /* is the stmt_list currently valid? */ TransactionId saved_xmin; /* if valid, replan when TransactionXmin --- 115,130 ---- * (if any), and any active plan executions, so the plan can be discarded * exactly when refcount goes to zero. Both the struct itself and the * subsidiary data live in the context denoted by the context field. ! * This makes it easy to free a no-longer-needed cached plan. (However, ! * if is_oneshot is true, the context does not belong solely to the CachedPlan ! * so no freeing is possible.) */ typedef struct CachedPlan { int magic; /* should equal CACHEDPLAN_MAGIC */ List *stmt_list; /* list of statement nodes (PlannedStmts and * bare utility statements) */ + bool is_oneshot; /* is it a "oneshot" plan? */ bool is_saved; /* is CachedPlan in a long-lived context? */ bool is_valid; /* is the stmt_list currently valid? */ TransactionId saved_xmin; /* if valid, replan when TransactionXmin *************** extern void ResetPlanCache(void); *** 129,134 **** --- 141,149 ---- extern CachedPlanSource *CreateCachedPlan(Node *raw_parse_tree, const char *query_string, const char *commandTag); + extern CachedPlanSource *CreateOneShotCachedPlan(Node *raw_parse_tree, + const char *query_string, + const char *commandTag); extern void CompleteCachedPlan(CachedPlanSource *plansource, List *querytree_list, MemoryContext querytree_context,