mirror of
https://github.com/postgres/postgres.git
synced 2025-07-31 22:04:40 +03:00
Make use of plancache module for SPI plans. In particular, since plpgsql
uses SPI plans, this finally fixes the ancient gotcha that you can't drop and recreate a temp table used by a plpgsql function. Along the way, clean up SPI's API a little bit by declaring SPI plan pointers as "SPIPlanPtr" instead of "void *". This is cosmetic but helps to forestall simple programming mistakes. (I have changed some but not all of the callers to match; there are still some "void *"'s in contrib and the PL's. This is intentional so that we can see if anyone's compiler complains about it.)
This commit is contained in:
Tom Lane
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/executor/spi.c,v 1.171 2007/03/13 00:33:40 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/executor/spi.c,v 1.172 2007/03/15 23:12:06 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -34,9 +34,9 @@ static int _SPI_stack_depth = 0; /* allocated size of _SPI_stack */
|
||||
static int _SPI_connected = -1;
|
||||
static int _SPI_curid = -1;
|
||||
|
||||
static void _SPI_prepare_plan(const char *src, _SPI_plan *plan);
|
||||
static void _SPI_prepare_plan(const char *src, SPIPlanPtr plan);
|
||||
|
||||
static int _SPI_execute_plan(_SPI_plan *plan,
|
||||
static int _SPI_execute_plan(SPIPlanPtr plan,
|
||||
Datum *Values, const char *Nulls,
|
||||
Snapshot snapshot, Snapshot crosscheck_snapshot,
|
||||
bool read_only, long tcount);
|
||||
@ -48,7 +48,8 @@ static void _SPI_error_callback(void *arg);
|
||||
static void _SPI_cursor_operation(Portal portal, bool forward, long count,
|
||||
DestReceiver *dest);
|
||||
|
||||
static _SPI_plan *_SPI_copy_plan(_SPI_plan *plan, int location);
|
||||
static SPIPlanPtr _SPI_copy_plan(SPIPlanPtr plan, MemoryContext parentcxt);
|
||||
static SPIPlanPtr _SPI_save_plan(SPIPlanPtr plan);
|
||||
|
||||
static int _SPI_begin_call(bool execmem);
|
||||
static int _SPI_end_call(bool procmem);
|
||||
@ -306,10 +307,8 @@ SPI_execute(const char *src, bool read_only, long tcount)
|
||||
if (res < 0)
|
||||
return res;
|
||||
|
||||
plan.plancxt = NULL; /* doesn't have own context */
|
||||
plan.query = src;
|
||||
plan.nargs = 0;
|
||||
plan.argtypes = NULL;
|
||||
memset(&plan, 0, sizeof(_SPI_plan));
|
||||
plan.magic = _SPI_PLAN_MAGIC;
|
||||
|
||||
_SPI_prepare_plan(src, &plan);
|
||||
|
||||
@ -330,22 +329,22 @@ SPI_exec(const char *src, long tcount)
|
||||
|
||||
/* Execute a previously prepared plan */
|
||||
int
|
||||
SPI_execute_plan(void *plan, Datum *Values, const char *Nulls,
|
||||
SPI_execute_plan(SPIPlanPtr plan, Datum *Values, const char *Nulls,
|
||||
bool read_only, long tcount)
|
||||
{
|
||||
int res;
|
||||
|
||||
if (plan == NULL || tcount < 0)
|
||||
if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC || tcount < 0)
|
||||
return SPI_ERROR_ARGUMENT;
|
||||
|
||||
if (((_SPI_plan *) plan)->nargs > 0 && Values == NULL)
|
||||
if (plan->nargs > 0 && Values == NULL)
|
||||
return SPI_ERROR_PARAM;
|
||||
|
||||
res = _SPI_begin_call(true);
|
||||
if (res < 0)
|
||||
return res;
|
||||
|
||||
res = _SPI_execute_plan((_SPI_plan *) plan,
|
||||
res = _SPI_execute_plan(plan,
|
||||
Values, Nulls,
|
||||
InvalidSnapshot, InvalidSnapshot,
|
||||
read_only, tcount);
|
||||
@ -356,7 +355,7 @@ SPI_execute_plan(void *plan, Datum *Values, const char *Nulls,
|
||||
|
||||
/* Obsolete version of SPI_execute_plan */
|
||||
int
|
||||
SPI_execp(void *plan, Datum *Values, const char *Nulls, long tcount)
|
||||
SPI_execp(SPIPlanPtr plan, Datum *Values, const char *Nulls, long tcount)
|
||||
{
|
||||
return SPI_execute_plan(plan, Values, Nulls, false, tcount);
|
||||
}
|
||||
@ -371,24 +370,24 @@ SPI_execp(void *plan, Datum *Values, const char *Nulls, long tcount)
|
||||
* fetching a new snapshot for each query.
|
||||
*/
|
||||
int
|
||||
SPI_execute_snapshot(void *plan,
|
||||
SPI_execute_snapshot(SPIPlanPtr plan,
|
||||
Datum *Values, const char *Nulls,
|
||||
Snapshot snapshot, Snapshot crosscheck_snapshot,
|
||||
bool read_only, long tcount)
|
||||
{
|
||||
int res;
|
||||
|
||||
if (plan == NULL || tcount < 0)
|
||||
if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC || tcount < 0)
|
||||
return SPI_ERROR_ARGUMENT;
|
||||
|
||||
if (((_SPI_plan *) plan)->nargs > 0 && Values == NULL)
|
||||
if (plan->nargs > 0 && Values == NULL)
|
||||
return SPI_ERROR_PARAM;
|
||||
|
||||
res = _SPI_begin_call(true);
|
||||
if (res < 0)
|
||||
return res;
|
||||
|
||||
res = _SPI_execute_plan((_SPI_plan *) plan,
|
||||
res = _SPI_execute_plan(plan,
|
||||
Values, Nulls,
|
||||
snapshot, crosscheck_snapshot,
|
||||
read_only, tcount);
|
||||
@ -397,11 +396,11 @@ SPI_execute_snapshot(void *plan,
|
||||
return res;
|
||||
}
|
||||
|
||||
void *
|
||||
SPIPlanPtr
|
||||
SPI_prepare(const char *src, int nargs, Oid *argtypes)
|
||||
{
|
||||
_SPI_plan plan;
|
||||
_SPI_plan *result;
|
||||
SPIPlanPtr result;
|
||||
|
||||
if (src == NULL || nargs < 0 || (nargs > 0 && argtypes == NULL))
|
||||
{
|
||||
@ -413,27 +412,28 @@ SPI_prepare(const char *src, int nargs, Oid *argtypes)
|
||||
if (SPI_result < 0)
|
||||
return NULL;
|
||||
|
||||
plan.plancxt = NULL; /* doesn't have own context */
|
||||
plan.query = src;
|
||||
memset(&plan, 0, sizeof(_SPI_plan));
|
||||
plan.magic = _SPI_PLAN_MAGIC;
|
||||
plan.nargs = nargs;
|
||||
plan.argtypes = argtypes;
|
||||
|
||||
_SPI_prepare_plan(src, &plan);
|
||||
|
||||
/* copy plan to procedure context */
|
||||
result = _SPI_copy_plan(&plan, _SPI_CPLAN_PROCXT);
|
||||
result = _SPI_copy_plan(&plan, _SPI_current->procCxt);
|
||||
|
||||
_SPI_end_call(true);
|
||||
|
||||
return (void *) result;
|
||||
return result;
|
||||
}
|
||||
|
||||
void *
|
||||
SPI_saveplan(void *plan)
|
||||
SPIPlanPtr
|
||||
SPI_saveplan(SPIPlanPtr plan)
|
||||
{
|
||||
_SPI_plan *newplan;
|
||||
SPIPlanPtr newplan;
|
||||
|
||||
if (plan == NULL)
|
||||
/* We don't currently support copying an already-saved plan */
|
||||
if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC || plan->saved)
|
||||
{
|
||||
SPI_result = SPI_ERROR_ARGUMENT;
|
||||
return NULL;
|
||||
@ -443,23 +443,36 @@ SPI_saveplan(void *plan)
|
||||
if (SPI_result < 0)
|
||||
return NULL;
|
||||
|
||||
newplan = _SPI_copy_plan((_SPI_plan *) plan, _SPI_CPLAN_TOPCXT);
|
||||
newplan = _SPI_save_plan(plan);
|
||||
|
||||
_SPI_curid--;
|
||||
SPI_result = 0;
|
||||
|
||||
return (void *) newplan;
|
||||
return newplan;
|
||||
}
|
||||
|
||||
int
|
||||
SPI_freeplan(void *plan)
|
||||
SPI_freeplan(SPIPlanPtr plan)
|
||||
{
|
||||
_SPI_plan *spiplan = (_SPI_plan *) plan;
|
||||
|
||||
if (plan == NULL)
|
||||
if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC)
|
||||
return SPI_ERROR_ARGUMENT;
|
||||
|
||||
MemoryContextDelete(spiplan->plancxt);
|
||||
/* If plancache.c owns the plancache entries, we must release them */
|
||||
if (plan->saved)
|
||||
{
|
||||
ListCell *lc;
|
||||
|
||||
foreach(lc, plan->plancache_list)
|
||||
{
|
||||
CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
|
||||
|
||||
DropCachedPlan(plansource);
|
||||
}
|
||||
}
|
||||
|
||||
/* Now get rid of the _SPI_plan and subsidiary data in its plancxt */
|
||||
MemoryContextDelete(plan->plancxt);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -819,18 +832,18 @@ SPI_freetuptable(SPITupleTable *tuptable)
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* SPI_cursor_open()
|
||||
*
|
||||
* Open a prepared SPI plan as a portal
|
||||
*/
|
||||
Portal
|
||||
SPI_cursor_open(const char *name, void *plan,
|
||||
SPI_cursor_open(const char *name, SPIPlanPtr plan,
|
||||
Datum *Values, const char *Nulls,
|
||||
bool read_only)
|
||||
{
|
||||
_SPI_plan *spiplan = (_SPI_plan *) plan;
|
||||
CachedPlanSource *plansource;
|
||||
CachedPlan *cplan;
|
||||
List *stmt_list;
|
||||
ParamListInfo paramLI;
|
||||
Snapshot snapshot;
|
||||
@ -842,25 +855,23 @@ SPI_cursor_open(const char *name, void *plan,
|
||||
* Check that the plan is something the Portal code will special-case as
|
||||
* returning one tupleset.
|
||||
*/
|
||||
if (!SPI_is_cursor_plan(spiplan))
|
||||
if (!SPI_is_cursor_plan(plan))
|
||||
{
|
||||
/* try to give a good error message */
|
||||
Node *stmt;
|
||||
|
||||
if (list_length(spiplan->stmt_list_list) != 1)
|
||||
if (list_length(plan->plancache_list) != 1)
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
|
||||
errmsg("cannot open multi-query plan as cursor")));
|
||||
stmt = PortalListGetPrimaryStmt((List *) linitial(spiplan->stmt_list_list));
|
||||
plansource = (CachedPlanSource *) linitial(plan->plancache_list);
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
|
||||
/* translator: %s is name of a SQL command, eg INSERT */
|
||||
errmsg("cannot open %s query as cursor",
|
||||
CreateCommandTag(stmt))));
|
||||
plansource->commandTag)));
|
||||
}
|
||||
|
||||
Assert(list_length(spiplan->stmt_list_list) == 1);
|
||||
stmt_list = (List *) linitial(spiplan->stmt_list_list);
|
||||
Assert(list_length(plan->plancache_list) == 1);
|
||||
plansource = (CachedPlanSource *) linitial(plan->plancache_list);
|
||||
|
||||
/* Reset SPI result (note we deliberately don't touch lastoid) */
|
||||
SPI_processed = 0;
|
||||
@ -880,23 +891,20 @@ SPI_cursor_open(const char *name, void *plan,
|
||||
portal = CreatePortal(name, false, false);
|
||||
}
|
||||
|
||||
/* Switch to portal's memory and copy the plans to there */
|
||||
oldcontext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
|
||||
stmt_list = copyObject(stmt_list);
|
||||
|
||||
/* If the plan has parameters, set them up */
|
||||
if (spiplan->nargs > 0)
|
||||
/* If the plan has parameters, copy them into the portal */
|
||||
if (plan->nargs > 0)
|
||||
{
|
||||
oldcontext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
|
||||
/* sizeof(ParamListInfoData) includes the first array element */
|
||||
paramLI = (ParamListInfo) palloc(sizeof(ParamListInfoData) +
|
||||
(spiplan->nargs - 1) *sizeof(ParamExternData));
|
||||
paramLI->numParams = spiplan->nargs;
|
||||
(plan->nargs - 1) *sizeof(ParamExternData));
|
||||
paramLI->numParams = plan->nargs;
|
||||
|
||||
for (k = 0; k < spiplan->nargs; k++)
|
||||
for (k = 0; k < plan->nargs; k++)
|
||||
{
|
||||
ParamExternData *prm = ¶mLI->params[k];
|
||||
|
||||
prm->ptype = spiplan->argtypes[k];
|
||||
prm->ptype = plan->argtypes[k];
|
||||
prm->pflags = 0;
|
||||
prm->isnull = (Nulls && Nulls[k] == 'n');
|
||||
if (prm->isnull)
|
||||
@ -915,21 +923,35 @@ SPI_cursor_open(const char *name, void *plan,
|
||||
paramTypByVal, paramTypLen);
|
||||
}
|
||||
}
|
||||
MemoryContextSwitchTo(oldcontext);
|
||||
}
|
||||
else
|
||||
paramLI = NULL;
|
||||
|
||||
if (plan->saved)
|
||||
{
|
||||
/* Replan if needed, and increment plan refcount for portal */
|
||||
cplan = RevalidateCachedPlan(plansource, false);
|
||||
stmt_list = cplan->stmt_list;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* No replan, but copy the plan into the portal's context */
|
||||
oldcontext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
|
||||
stmt_list = copyObject(plansource->plan->stmt_list);
|
||||
MemoryContextSwitchTo(oldcontext);
|
||||
cplan = NULL; /* portal shouldn't depend on cplan */
|
||||
}
|
||||
|
||||
/*
|
||||
* Set up the portal.
|
||||
*/
|
||||
PortalDefineQuery(portal,
|
||||
NULL, /* no statement name */
|
||||
spiplan->query,
|
||||
CreateCommandTag(PortalListGetPrimaryStmt(stmt_list)),
|
||||
plansource->query_string,
|
||||
plansource->commandTag,
|
||||
stmt_list,
|
||||
NULL);
|
||||
|
||||
MemoryContextSwitchTo(oldcontext);
|
||||
cplan);
|
||||
|
||||
/*
|
||||
* Set up options for portal.
|
||||
@ -1023,28 +1045,29 @@ SPI_cursor_close(Portal portal)
|
||||
* parameter is at index zero.
|
||||
*/
|
||||
Oid
|
||||
SPI_getargtypeid(void *plan, int argIndex)
|
||||
SPI_getargtypeid(SPIPlanPtr plan, int argIndex)
|
||||
{
|
||||
if (plan == NULL || argIndex < 0 || argIndex >= ((_SPI_plan *) plan)->nargs)
|
||||
if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC ||
|
||||
argIndex < 0 || argIndex >= plan->nargs)
|
||||
{
|
||||
SPI_result = SPI_ERROR_ARGUMENT;
|
||||
return InvalidOid;
|
||||
}
|
||||
return ((_SPI_plan *) plan)->argtypes[argIndex];
|
||||
return plan->argtypes[argIndex];
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns the number of arguments for the prepared plan.
|
||||
*/
|
||||
int
|
||||
SPI_getargcount(void *plan)
|
||||
SPI_getargcount(SPIPlanPtr plan)
|
||||
{
|
||||
if (plan == NULL)
|
||||
if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC)
|
||||
{
|
||||
SPI_result = SPI_ERROR_ARGUMENT;
|
||||
return -1;
|
||||
}
|
||||
return ((_SPI_plan *) plan)->nargs;
|
||||
return plan->nargs;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1057,31 +1080,32 @@ SPI_getargcount(void *plan)
|
||||
* plan: A plan previously prepared using SPI_prepare
|
||||
*/
|
||||
bool
|
||||
SPI_is_cursor_plan(void *plan)
|
||||
SPI_is_cursor_plan(SPIPlanPtr plan)
|
||||
{
|
||||
_SPI_plan *spiplan = (_SPI_plan *) plan;
|
||||
CachedPlanSource *plansource;
|
||||
CachedPlan *cplan;
|
||||
|
||||
if (spiplan == NULL)
|
||||
if (plan == NULL || plan->magic != _SPI_PLAN_MAGIC)
|
||||
{
|
||||
SPI_result = SPI_ERROR_ARGUMENT;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (list_length(spiplan->stmt_list_list) != 1)
|
||||
if (list_length(plan->plancache_list) != 1)
|
||||
return false; /* not exactly 1 pre-rewrite command */
|
||||
plansource = (CachedPlanSource *) linitial(plan->plancache_list);
|
||||
|
||||
switch (ChoosePortalStrategy((List *) linitial(spiplan->stmt_list_list)))
|
||||
if (plan->saved)
|
||||
{
|
||||
case PORTAL_ONE_SELECT:
|
||||
case PORTAL_ONE_RETURNING:
|
||||
case PORTAL_UTIL_SELECT:
|
||||
/* OK */
|
||||
return true;
|
||||
|
||||
case PORTAL_MULTI_QUERY:
|
||||
/* will not return tuples */
|
||||
break;
|
||||
/* Make sure the plan is up to date */
|
||||
cplan = RevalidateCachedPlan(plansource, true);
|
||||
ReleaseCachedPlan(cplan, true);
|
||||
}
|
||||
|
||||
/* Does it return tuples? */
|
||||
if (plansource->resultDesc)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -1248,13 +1272,15 @@ spi_printtup(TupleTableSlot *slot, DestReceiver *self)
|
||||
*
|
||||
* At entry, plan->argtypes and plan->nargs must be valid.
|
||||
*
|
||||
* Result lists are stored into *plan.
|
||||
* Results are stored into *plan (specifically, plan->plancache_list).
|
||||
* Note however that the result trees are all in CurrentMemoryContext
|
||||
* and need to be copied somewhere to survive.
|
||||
*/
|
||||
static void
|
||||
_SPI_prepare_plan(const char *src, _SPI_plan *plan)
|
||||
_SPI_prepare_plan(const char *src, SPIPlanPtr plan)
|
||||
{
|
||||
List *raw_parsetree_list;
|
||||
List *stmt_list_list;
|
||||
List *plancache_list;
|
||||
ListCell *list_item;
|
||||
ErrorContextCallback spierrcontext;
|
||||
Oid *argtypes = plan->argtypes;
|
||||
@ -1282,26 +1308,44 @@ _SPI_prepare_plan(const char *src, _SPI_plan *plan)
|
||||
raw_parsetree_list = pg_parse_query(src);
|
||||
|
||||
/*
|
||||
* Do parse analysis and rule rewrite for each raw parsetree.
|
||||
*
|
||||
* We save the results from each raw parsetree as a separate sublist.
|
||||
* This allows _SPI_execute_plan() to know where the boundaries between
|
||||
* original queries fall.
|
||||
* Do parse analysis and rule rewrite for each raw parsetree, then
|
||||
* cons up a phony plancache entry for each one.
|
||||
*/
|
||||
stmt_list_list = NIL;
|
||||
plancache_list = NIL;
|
||||
|
||||
foreach(list_item, raw_parsetree_list)
|
||||
{
|
||||
Node *parsetree = (Node *) lfirst(list_item);
|
||||
List *query_list;
|
||||
List *stmt_list;
|
||||
CachedPlanSource *plansource;
|
||||
CachedPlan *cplan;
|
||||
|
||||
query_list = pg_analyze_and_rewrite(parsetree, src, argtypes, nargs);
|
||||
/* Need a copyObject here to keep parser from modifying raw tree */
|
||||
stmt_list = pg_analyze_and_rewrite(copyObject(parsetree),
|
||||
src, argtypes, nargs);
|
||||
stmt_list = pg_plan_queries(stmt_list, NULL, false);
|
||||
|
||||
stmt_list_list = lappend(stmt_list_list,
|
||||
pg_plan_queries(query_list, NULL, false));
|
||||
plansource = (CachedPlanSource *) palloc0(sizeof(CachedPlanSource));
|
||||
cplan = (CachedPlan *) palloc0(sizeof(CachedPlan));
|
||||
|
||||
plansource->raw_parse_tree = parsetree;
|
||||
/* cast-away-const here is a bit ugly, but there's no reason to copy */
|
||||
plansource->query_string = (char *) src;
|
||||
plansource->commandTag = CreateCommandTag(parsetree);
|
||||
plansource->param_types = argtypes;
|
||||
plansource->num_params = nargs;
|
||||
plansource->fully_planned = true;
|
||||
plansource->fixed_result = false;
|
||||
plansource->resultDesc = PlanCacheComputeResultDesc(stmt_list);
|
||||
plansource->plan = cplan;
|
||||
|
||||
cplan->stmt_list = stmt_list;
|
||||
cplan->fully_planned = true;
|
||||
|
||||
plancache_list = lappend(plancache_list, plansource);
|
||||
}
|
||||
|
||||
plan->stmt_list_list = stmt_list_list;
|
||||
plan->plancache_list = plancache_list;
|
||||
|
||||
/*
|
||||
* Pop the error context stack
|
||||
@ -1319,7 +1363,7 @@ _SPI_prepare_plan(const char *src, _SPI_plan *plan)
|
||||
* tcount: execution tuple-count limit, or 0 for none
|
||||
*/
|
||||
static int
|
||||
_SPI_execute_plan(_SPI_plan *plan, Datum *Values, const char *Nulls,
|
||||
_SPI_execute_plan(SPIPlanPtr plan, Datum *Values, const char *Nulls,
|
||||
Snapshot snapshot, Snapshot crosscheck_snapshot,
|
||||
bool read_only, long tcount)
|
||||
{
|
||||
@ -1334,10 +1378,11 @@ _SPI_execute_plan(_SPI_plan *plan, Datum *Values, const char *Nulls,
|
||||
saveActiveSnapshot = ActiveSnapshot;
|
||||
PG_TRY();
|
||||
{
|
||||
ListCell *stmt_list_list_item;
|
||||
ListCell *lc1;
|
||||
ErrorContextCallback spierrcontext;
|
||||
int nargs = plan->nargs;
|
||||
ParamListInfo paramLI;
|
||||
CachedPlan *cplan = NULL;
|
||||
|
||||
/* Convert parameters to form wanted by executor */
|
||||
if (nargs > 0)
|
||||
@ -1366,18 +1411,34 @@ _SPI_execute_plan(_SPI_plan *plan, Datum *Values, const char *Nulls,
|
||||
* Setup error traceback support for ereport()
|
||||
*/
|
||||
spierrcontext.callback = _SPI_error_callback;
|
||||
spierrcontext.arg = (void *) plan->query;
|
||||
spierrcontext.arg = NULL;
|
||||
spierrcontext.previous = error_context_stack;
|
||||
error_context_stack = &spierrcontext;
|
||||
|
||||
foreach(stmt_list_list_item, plan->stmt_list_list)
|
||||
foreach(lc1, plan->plancache_list)
|
||||
{
|
||||
List *stmt_list = (List *) lfirst(stmt_list_list_item);
|
||||
ListCell *stmt_list_item;
|
||||
CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc1);
|
||||
List *stmt_list;
|
||||
ListCell *lc2;
|
||||
|
||||
foreach(stmt_list_item, stmt_list)
|
||||
spierrcontext.arg = (void *) plansource->query_string;
|
||||
|
||||
if (plan->saved)
|
||||
{
|
||||
Node *stmt = (Node *) lfirst(stmt_list_item);
|
||||
/* Replan if needed, and increment plan refcount locally */
|
||||
cplan = RevalidateCachedPlan(plansource, true);
|
||||
stmt_list = cplan->stmt_list;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* No replan here */
|
||||
cplan = NULL;
|
||||
stmt_list = plansource->plan->stmt_list;
|
||||
}
|
||||
|
||||
foreach(lc2, stmt_list)
|
||||
{
|
||||
Node *stmt = (Node *) lfirst(lc2);
|
||||
bool canSetTag;
|
||||
QueryDesc *qdesc;
|
||||
DestReceiver *dest;
|
||||
@ -1510,10 +1571,19 @@ _SPI_execute_plan(_SPI_plan *plan, Datum *Values, const char *Nulls,
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
/* Done with this plan, so release refcount */
|
||||
if (cplan)
|
||||
ReleaseCachedPlan(cplan, true);
|
||||
cplan = NULL;
|
||||
}
|
||||
|
||||
fail:
|
||||
|
||||
/* We no longer need the cached plan refcount, if any */
|
||||
if (cplan)
|
||||
ReleaseCachedPlan(cplan, true);
|
||||
|
||||
/*
|
||||
* Pop the error context stack
|
||||
*/
|
||||
@ -1772,22 +1842,18 @@ _SPI_checktuples(void)
|
||||
return failed;
|
||||
}
|
||||
|
||||
static _SPI_plan *
|
||||
_SPI_copy_plan(_SPI_plan *plan, int location)
|
||||
/*
|
||||
* Make an "unsaved" copy of the given plan, in a child context of parentcxt.
|
||||
*/
|
||||
static SPIPlanPtr
|
||||
_SPI_copy_plan(SPIPlanPtr plan, MemoryContext parentcxt)
|
||||
{
|
||||
_SPI_plan *newplan;
|
||||
MemoryContext oldcxt;
|
||||
SPIPlanPtr newplan;
|
||||
MemoryContext plancxt;
|
||||
MemoryContext parentcxt;
|
||||
MemoryContext oldcxt;
|
||||
ListCell *lc;
|
||||
|
||||
/* Determine correct parent for the plan's memory context */
|
||||
if (location == _SPI_CPLAN_PROCXT)
|
||||
parentcxt = _SPI_current->procCxt;
|
||||
else if (location == _SPI_CPLAN_TOPCXT)
|
||||
parentcxt = TopMemoryContext;
|
||||
else
|
||||
/* (this case not currently used) */
|
||||
parentcxt = CurrentMemoryContext;
|
||||
Assert(!plan->saved); /* not currently supported */
|
||||
|
||||
/*
|
||||
* Create a memory context for the plan. We don't expect the plan to be
|
||||
@ -1801,10 +1867,11 @@ _SPI_copy_plan(_SPI_plan *plan, int location)
|
||||
oldcxt = MemoryContextSwitchTo(plancxt);
|
||||
|
||||
/* Copy the SPI plan into its own context */
|
||||
newplan = (_SPI_plan *) palloc(sizeof(_SPI_plan));
|
||||
newplan = (SPIPlanPtr) palloc(sizeof(_SPI_plan));
|
||||
newplan->magic = _SPI_PLAN_MAGIC;
|
||||
newplan->saved = false;
|
||||
newplan->plancache_list = NIL;
|
||||
newplan->plancxt = plancxt;
|
||||
newplan->query = pstrdup(plan->query);
|
||||
newplan->stmt_list_list = (List *) copyObject(plan->stmt_list_list);
|
||||
newplan->nargs = plan->nargs;
|
||||
if (plan->nargs > 0)
|
||||
{
|
||||
@ -1814,6 +1881,101 @@ _SPI_copy_plan(_SPI_plan *plan, int location)
|
||||
else
|
||||
newplan->argtypes = NULL;
|
||||
|
||||
foreach(lc, plan->plancache_list)
|
||||
{
|
||||
CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
|
||||
CachedPlanSource *newsource;
|
||||
CachedPlan *cplan;
|
||||
CachedPlan *newcplan;
|
||||
|
||||
/* Note: we assume we don't need to revalidate the plan */
|
||||
cplan = plansource->plan;
|
||||
|
||||
newsource = (CachedPlanSource *) palloc0(sizeof(CachedPlanSource));
|
||||
newcplan = (CachedPlan *) palloc0(sizeof(CachedPlan));
|
||||
|
||||
newsource->raw_parse_tree = copyObject(plansource->raw_parse_tree);
|
||||
newsource->query_string = pstrdup(plansource->query_string);
|
||||
newsource->commandTag = plansource->commandTag;
|
||||
newsource->param_types = newplan->argtypes;
|
||||
newsource->num_params = newplan->nargs;
|
||||
newsource->fully_planned = plansource->fully_planned;
|
||||
newsource->fixed_result = plansource->fixed_result;
|
||||
if (plansource->resultDesc)
|
||||
newsource->resultDesc = CreateTupleDescCopy(plansource->resultDesc);
|
||||
newsource->plan = newcplan;
|
||||
|
||||
newcplan->stmt_list = copyObject(cplan->stmt_list);
|
||||
newcplan->fully_planned = cplan->fully_planned;
|
||||
|
||||
newplan->plancache_list = lappend(newplan->plancache_list, newsource);
|
||||
}
|
||||
|
||||
MemoryContextSwitchTo(oldcxt);
|
||||
|
||||
return newplan;
|
||||
}
|
||||
|
||||
/*
|
||||
* Make a "saved" copy of the given plan, entrusting everything to plancache.c
|
||||
*/
|
||||
static SPIPlanPtr
|
||||
_SPI_save_plan(SPIPlanPtr plan)
|
||||
{
|
||||
SPIPlanPtr newplan;
|
||||
MemoryContext plancxt;
|
||||
MemoryContext oldcxt;
|
||||
ListCell *lc;
|
||||
|
||||
Assert(!plan->saved); /* not currently supported */
|
||||
|
||||
/*
|
||||
* Create a memory context for the plan. We don't expect the plan to be
|
||||
* very large, so use smaller-than-default alloc parameters.
|
||||
*/
|
||||
plancxt = AllocSetContextCreate(CacheMemoryContext,
|
||||
"SPI Plan",
|
||||
ALLOCSET_SMALL_MINSIZE,
|
||||
ALLOCSET_SMALL_INITSIZE,
|
||||
ALLOCSET_SMALL_MAXSIZE);
|
||||
oldcxt = MemoryContextSwitchTo(plancxt);
|
||||
|
||||
/* Copy the SPI plan into its own context */
|
||||
newplan = (SPIPlanPtr) palloc(sizeof(_SPI_plan));
|
||||
newplan->magic = _SPI_PLAN_MAGIC;
|
||||
newplan->saved = true;
|
||||
newplan->plancache_list = NIL;
|
||||
newplan->plancxt = plancxt;
|
||||
newplan->nargs = plan->nargs;
|
||||
if (plan->nargs > 0)
|
||||
{
|
||||
newplan->argtypes = (Oid *) palloc(plan->nargs * sizeof(Oid));
|
||||
memcpy(newplan->argtypes, plan->argtypes, plan->nargs * sizeof(Oid));
|
||||
}
|
||||
else
|
||||
newplan->argtypes = NULL;
|
||||
|
||||
foreach(lc, plan->plancache_list)
|
||||
{
|
||||
CachedPlanSource *plansource = (CachedPlanSource *) lfirst(lc);
|
||||
CachedPlanSource *newsource;
|
||||
CachedPlan *cplan;
|
||||
|
||||
/* Note: we assume we don't need to revalidate the plan */
|
||||
cplan = plansource->plan;
|
||||
|
||||
newsource = CreateCachedPlan(plansource->raw_parse_tree,
|
||||
plansource->query_string,
|
||||
plansource->commandTag,
|
||||
newplan->argtypes,
|
||||
newplan->nargs,
|
||||
cplan->stmt_list,
|
||||
true,
|
||||
false);
|
||||
|
||||
newplan->plancache_list = lappend(newplan->plancache_list, newsource);
|
||||
}
|
||||
|
||||
MemoryContextSwitchTo(oldcxt);
|
||||
|
||||
return newplan;
|
||||
|
||||
@ -8,16 +8,14 @@
|
||||
* across query and transaction boundaries, in fact they live as long as
|
||||
* the backend does. This works because the hashtable structures
|
||||
* themselves are allocated by dynahash.c in its permanent DynaHashCxt,
|
||||
* and the parse/plan node trees they point to are copied into
|
||||
* TopMemoryContext using SPI_saveplan(). This is pretty ugly, since there
|
||||
* is no way to free a no-longer-needed plan tree, but then again we don't
|
||||
* yet have any bookkeeping that would allow us to detect that a plan isn't
|
||||
* needed anymore. Improve it someday.
|
||||
* and the SPI plans they point to are saved using SPI_saveplan().
|
||||
* There is not currently any provision for throwing away a no-longer-needed
|
||||
* plan --- consider improving this someday.
|
||||
*
|
||||
*
|
||||
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/backend/utils/adt/ri_triggers.c,v 1.91 2007/02/14 01:58:57 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/utils/adt/ri_triggers.c,v 1.92 2007/03/15 23:12:06 tgl Exp $
|
||||
*
|
||||
* ----------
|
||||
*/
|
||||
@ -35,7 +33,7 @@
|
||||
#include "catalog/pg_constraint.h"
|
||||
#include "catalog/pg_operator.h"
|
||||
#include "commands/trigger.h"
|
||||
#include "executor/spi_priv.h"
|
||||
#include "executor/spi.h"
|
||||
#include "parser/parse_coerce.h"
|
||||
#include "parser/parse_relation.h"
|
||||
#include "miscadmin.h"
|
||||
@ -135,7 +133,7 @@ typedef struct RI_QueryKey
|
||||
typedef struct RI_QueryHashEntry
|
||||
{
|
||||
RI_QueryKey key;
|
||||
void *plan;
|
||||
SPIPlanPtr plan;
|
||||
} RI_QueryHashEntry;
|
||||
|
||||
|
||||
@ -206,18 +204,18 @@ static bool ri_Check_Pk_Match(Relation pk_rel, Relation fk_rel,
|
||||
const RI_ConstraintInfo *riinfo);
|
||||
|
||||
static void ri_InitHashTables(void);
|
||||
static void *ri_FetchPreparedPlan(RI_QueryKey *key);
|
||||
static void ri_HashPreparedPlan(RI_QueryKey *key, void *plan);
|
||||
static SPIPlanPtr ri_FetchPreparedPlan(RI_QueryKey *key);
|
||||
static void ri_HashPreparedPlan(RI_QueryKey *key, SPIPlanPtr plan);
|
||||
static RI_CompareHashEntry *ri_HashCompareOp(Oid eq_opr, Oid typeid);
|
||||
|
||||
static void ri_CheckTrigger(FunctionCallInfo fcinfo, const char *funcname,
|
||||
int tgkind);
|
||||
static void ri_FetchConstraintInfo(RI_ConstraintInfo *riinfo,
|
||||
Trigger *trigger, Relation trig_rel, bool rel_is_pk);
|
||||
static void *ri_PlanCheck(const char *querystr, int nargs, Oid *argtypes,
|
||||
static SPIPlanPtr ri_PlanCheck(const char *querystr, int nargs, Oid *argtypes,
|
||||
RI_QueryKey *qkey, Relation fk_rel, Relation pk_rel,
|
||||
bool cache_plan);
|
||||
static bool ri_PerformCheck(RI_QueryKey *qkey, void *qplan,
|
||||
static bool ri_PerformCheck(RI_QueryKey *qkey, SPIPlanPtr qplan,
|
||||
Relation fk_rel, Relation pk_rel,
|
||||
HeapTuple old_tuple, HeapTuple new_tuple,
|
||||
bool detectNewRows,
|
||||
@ -248,7 +246,7 @@ RI_FKey_check(PG_FUNCTION_ARGS)
|
||||
HeapTuple old_row;
|
||||
Buffer new_row_buf;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
int i;
|
||||
|
||||
/*
|
||||
@ -542,7 +540,7 @@ ri_Check_Pk_Match(Relation pk_rel, Relation fk_rel,
|
||||
HeapTuple old_row,
|
||||
const RI_ConstraintInfo *riinfo)
|
||||
{
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
RI_QueryKey qkey;
|
||||
int i;
|
||||
bool result;
|
||||
@ -678,7 +676,7 @@ RI_FKey_noaction_del(PG_FUNCTION_ARGS)
|
||||
Relation pk_rel;
|
||||
HeapTuple old_row;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
int i;
|
||||
|
||||
/*
|
||||
@ -855,7 +853,7 @@ RI_FKey_noaction_upd(PG_FUNCTION_ARGS)
|
||||
HeapTuple new_row;
|
||||
HeapTuple old_row;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
int i;
|
||||
|
||||
/*
|
||||
@ -1040,7 +1038,7 @@ RI_FKey_cascade_del(PG_FUNCTION_ARGS)
|
||||
Relation pk_rel;
|
||||
HeapTuple old_row;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
int i;
|
||||
|
||||
/*
|
||||
@ -1203,7 +1201,7 @@ RI_FKey_cascade_upd(PG_FUNCTION_ARGS)
|
||||
HeapTuple new_row;
|
||||
HeapTuple old_row;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
int i;
|
||||
int j;
|
||||
|
||||
@ -1397,7 +1395,7 @@ RI_FKey_restrict_del(PG_FUNCTION_ARGS)
|
||||
Relation pk_rel;
|
||||
HeapTuple old_row;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
int i;
|
||||
|
||||
/*
|
||||
@ -1569,7 +1567,7 @@ RI_FKey_restrict_upd(PG_FUNCTION_ARGS)
|
||||
HeapTuple new_row;
|
||||
HeapTuple old_row;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
int i;
|
||||
|
||||
/*
|
||||
@ -1744,7 +1742,7 @@ RI_FKey_setnull_del(PG_FUNCTION_ARGS)
|
||||
Relation pk_rel;
|
||||
HeapTuple old_row;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
int i;
|
||||
|
||||
/*
|
||||
@ -1916,7 +1914,7 @@ RI_FKey_setnull_upd(PG_FUNCTION_ARGS)
|
||||
HeapTuple new_row;
|
||||
HeapTuple old_row;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
int i;
|
||||
bool use_cached_query;
|
||||
|
||||
@ -2130,7 +2128,7 @@ RI_FKey_setdefault_del(PG_FUNCTION_ARGS)
|
||||
Relation pk_rel;
|
||||
HeapTuple old_row;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
|
||||
/*
|
||||
* Check that this is a valid trigger call on the right time and event.
|
||||
@ -2313,7 +2311,7 @@ RI_FKey_setdefault_upd(PG_FUNCTION_ARGS)
|
||||
HeapTuple new_row;
|
||||
HeapTuple old_row;
|
||||
RI_QueryKey qkey;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
|
||||
/*
|
||||
* Check that this is a valid trigger call on the right time and event.
|
||||
@ -2637,7 +2635,7 @@ RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel)
|
||||
int old_work_mem;
|
||||
char workmembuf[32];
|
||||
int spi_result;
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
|
||||
/*
|
||||
* Check to make sure current user has enough permissions to do the test
|
||||
@ -3165,12 +3163,12 @@ ri_FetchConstraintInfo(RI_ConstraintInfo *riinfo,
|
||||
* If cache_plan is true, the plan is saved into our plan hashtable
|
||||
* so that we don't need to plan it again.
|
||||
*/
|
||||
static void *
|
||||
static SPIPlanPtr
|
||||
ri_PlanCheck(const char *querystr, int nargs, Oid *argtypes,
|
||||
RI_QueryKey *qkey, Relation fk_rel, Relation pk_rel,
|
||||
bool cache_plan)
|
||||
{
|
||||
void *qplan;
|
||||
SPIPlanPtr qplan;
|
||||
Relation query_rel;
|
||||
Oid save_uid;
|
||||
|
||||
@ -3212,7 +3210,7 @@ ri_PlanCheck(const char *querystr, int nargs, Oid *argtypes,
|
||||
* Perform a query to enforce an RI restriction
|
||||
*/
|
||||
static bool
|
||||
ri_PerformCheck(RI_QueryKey *qkey, void *qplan,
|
||||
ri_PerformCheck(RI_QueryKey *qkey, SPIPlanPtr qplan,
|
||||
Relation fk_rel, Relation pk_rel,
|
||||
HeapTuple old_tuple, HeapTuple new_tuple,
|
||||
bool detectNewRows,
|
||||
@ -3576,7 +3574,7 @@ ri_InitHashTables(void)
|
||||
* and saved SPI execution plans. Return the plan if found or NULL.
|
||||
* ----------
|
||||
*/
|
||||
static void *
|
||||
static SPIPlanPtr
|
||||
ri_FetchPreparedPlan(RI_QueryKey *key)
|
||||
{
|
||||
RI_QueryHashEntry *entry;
|
||||
@ -3606,7 +3604,7 @@ ri_FetchPreparedPlan(RI_QueryKey *key)
|
||||
* ----------
|
||||
*/
|
||||
static void
|
||||
ri_HashPreparedPlan(RI_QueryKey *key, void *plan)
|
||||
ri_HashPreparedPlan(RI_QueryKey *key, SPIPlanPtr plan)
|
||||
{
|
||||
RI_QueryHashEntry *entry;
|
||||
bool found;
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.252 2007/02/27 23:48:08 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.253 2007/03/15 23:12:06 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -105,9 +105,9 @@ typedef struct
|
||||
* Global data
|
||||
* ----------
|
||||
*/
|
||||
static void *plan_getrulebyoid = NULL;
|
||||
static SPIPlanPtr plan_getrulebyoid = NULL;
|
||||
static char *query_getrulebyoid = "SELECT * FROM pg_catalog.pg_rewrite WHERE oid = $1";
|
||||
static void *plan_getviewrule = NULL;
|
||||
static SPIPlanPtr plan_getviewrule = NULL;
|
||||
static char *query_getviewrule = "SELECT * FROM pg_catalog.pg_rewrite WHERE ev_class = $1 AND rulename = $2";
|
||||
|
||||
|
||||
@ -250,7 +250,7 @@ pg_get_ruledef_worker(Oid ruleoid, int prettyFlags)
|
||||
if (plan_getrulebyoid == NULL)
|
||||
{
|
||||
Oid argtypes[1];
|
||||
void *plan;
|
||||
SPIPlanPtr plan;
|
||||
|
||||
argtypes[0] = OIDOID;
|
||||
plan = SPI_prepare(query_getrulebyoid, 1, argtypes);
|
||||
@ -380,7 +380,7 @@ pg_get_viewdef_worker(Oid viewoid, int prettyFlags)
|
||||
if (plan_getviewrule == NULL)
|
||||
{
|
||||
Oid argtypes[2];
|
||||
void *plan;
|
||||
SPIPlanPtr plan;
|
||||
|
||||
argtypes[0] = OIDOID;
|
||||
argtypes[1] = NAMEOID;
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* $PostgreSQL: pgsql/src/backend/utils/adt/xml.c,v 1.34 2007/03/03 19:32:55 neilc Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/utils/adt/xml.c,v 1.35 2007/03/15 23:12:06 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -1800,7 +1800,7 @@ query_to_xmlschema(PG_FUNCTION_ARGS)
|
||||
const char *targetns = _textout(PG_GETARG_TEXT_P(3));
|
||||
|
||||
const char *result;
|
||||
void *plan;
|
||||
SPIPlanPtr plan;
|
||||
Portal portal;
|
||||
|
||||
SPI_connect();
|
||||
@ -1871,7 +1871,7 @@ query_to_xml_and_xmlschema(PG_FUNCTION_ARGS)
|
||||
const char *targetns = _textout(PG_GETARG_TEXT_P(3));
|
||||
|
||||
const char *xmlschema;
|
||||
void *plan;
|
||||
SPIPlanPtr plan;
|
||||
Portal portal;
|
||||
|
||||
SPI_connect();
|
||||
|
||||
24
src/backend/utils/cache/plancache.c
vendored
24
src/backend/utils/cache/plancache.c
vendored
@ -33,7 +33,7 @@
|
||||
* Portions Copyright (c) 1994, Regents of the University of California
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/backend/utils/cache/plancache.c,v 1.1 2007/03/13 00:33:42 tgl Exp $
|
||||
* $PostgreSQL: pgsql/src/backend/utils/cache/plancache.c,v 1.2 2007/03/15 23:12:06 tgl Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -77,7 +77,6 @@ static void ScanQueryForRelids(Query *parsetree,
|
||||
void *arg);
|
||||
static bool ScanQueryWalker(Node *node, ScanQueryWalkerContext *context);
|
||||
static bool rowmark_member(List *rowMarks, int rt_index);
|
||||
static TupleDesc ComputeResultDesc(List *stmt_list);
|
||||
static void PlanCacheCallback(Datum arg, Oid relid);
|
||||
static void InvalRelid(Oid relid, LOCKMODE lockmode,
|
||||
InvalRelidContext *context);
|
||||
@ -153,7 +152,7 @@ CreateCachedPlan(Node *raw_parse_tree,
|
||||
plansource->fully_planned = fully_planned;
|
||||
plansource->fixed_result = fixed_result;
|
||||
plansource->generation = 0; /* StoreCachedPlan will increment */
|
||||
plansource->resultDesc = ComputeResultDesc(stmt_list);
|
||||
plansource->resultDesc = PlanCacheComputeResultDesc(stmt_list);
|
||||
plansource->plan = NULL;
|
||||
plansource->context = source_context;
|
||||
plansource->orig_plan = NULL;
|
||||
@ -225,7 +224,7 @@ FastCreateCachedPlan(Node *raw_parse_tree,
|
||||
plansource->fully_planned = fully_planned;
|
||||
plansource->fixed_result = fixed_result;
|
||||
plansource->generation = 0; /* StoreCachedPlan will increment */
|
||||
plansource->resultDesc = ComputeResultDesc(stmt_list);
|
||||
plansource->resultDesc = PlanCacheComputeResultDesc(stmt_list);
|
||||
plansource->plan = NULL;
|
||||
plansource->context = context;
|
||||
plansource->orig_plan = NULL;
|
||||
@ -271,12 +270,13 @@ StoreCachedPlan(CachedPlanSource *plansource,
|
||||
{
|
||||
/*
|
||||
* Make a dedicated memory context for the CachedPlan and its
|
||||
* subsidiary data.
|
||||
* subsidiary data. It's probably not going to be large, but
|
||||
* just in case, use the default maxsize parameter.
|
||||
*/
|
||||
plan_context = AllocSetContextCreate(CacheMemoryContext,
|
||||
"CachedPlan",
|
||||
ALLOCSET_DEFAULT_MINSIZE,
|
||||
ALLOCSET_DEFAULT_INITSIZE,
|
||||
ALLOCSET_SMALL_MINSIZE,
|
||||
ALLOCSET_SMALL_INITSIZE,
|
||||
ALLOCSET_DEFAULT_MAXSIZE);
|
||||
|
||||
/*
|
||||
@ -445,7 +445,7 @@ RevalidateCachedPlan(CachedPlanSource *plansource, bool useResOwner)
|
||||
* Check or update the result tupdesc. XXX should we use a weaker
|
||||
* condition than equalTupleDescs() here?
|
||||
*/
|
||||
resultDesc = ComputeResultDesc(slist);
|
||||
resultDesc = PlanCacheComputeResultDesc(slist);
|
||||
if (resultDesc == NULL && plansource->resultDesc == NULL)
|
||||
{
|
||||
/* OK, doesn't return tuples */
|
||||
@ -718,14 +718,14 @@ rowmark_member(List *rowMarks, int rt_index)
|
||||
}
|
||||
|
||||
/*
|
||||
* ComputeResultDesc: given a list of either fully-planned statements or
|
||||
* Queries, determine the result tupledesc it will produce. Returns NULL
|
||||
* PlanCacheComputeResultDesc: given a list of either fully-planned statements
|
||||
* or Queries, determine the result tupledesc it will produce. Returns NULL
|
||||
* if the execution will not return tuples.
|
||||
*
|
||||
* Note: the result is created or copied into current memory context.
|
||||
*/
|
||||
static TupleDesc
|
||||
ComputeResultDesc(List *stmt_list)
|
||||
TupleDesc
|
||||
PlanCacheComputeResultDesc(List *stmt_list)
|
||||
{
|
||||
Node *node;
|
||||
Query *query;
|
||||
|
||||
Reference in New Issue
Block a user