open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix plancache so that any required replanning is done with the same

Browse Source 
search_path that was active when the plan was first made.  To do this,
improve namespace.c to support a stack of "override" search path settings
(we must have a stack since nested replan events are entirely possible).
This facility replaces the "special namespace" hack formerly used by
CREATE SCHEMA, and should be able to support per-function search path
settings as well.
REL8_3_STABLE
Tom Lane 19 years ago
parent 4c35ec53a9
commit 547b6e537a
7 changed files with 389 additions and 113 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 375
      src/backend/catalog/namespace.c
  2. 10
      src/backend/commands/schemacmds.c
  3. 28
      src/backend/utils/cache/plancache.c
  4. 17
      src/include/catalog/namespace.h
  5. 3
      src/include/utils/plancache.h
  6. 39
      src/test/regress/expected/plancache.out
  7. 30
      src/test/regress/sql/plancache.sql

375
src/backend/catalog/namespace.c
Unescape View File

@ -13,7 +13,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/namespace.c,v 1.92 2007/02/14 01:58:56 tgl Exp $
* $PostgreSQL: pgsql/src/backend/catalog/namespace.c,v 1.93 2007/03/23 19:53:51 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -46,16 +46,15 @@
/*
* The namespace search path is a possibly-empty list of namespace OIDs.
* In addition to the explicit list, several implicitly-searched namespaces
* In addition to the explicit list, implicitly-searched namespaces
* may be included:
*
* 1. If a "special" namespace has been set by PushSpecialNamespace, it is
* always searched first. (This is a hack for CREATE SCHEMA.)
* 1. If a TEMP table namespace has been initialized in this session, it
* is implicitly searched first. (The only time this doesn't happen is
* when we are obeying an override search path spec that says not to use the
* temp namespace, or the temp namespace is included in the explicit list.)
*
* 2. If a TEMP table namespace has been initialized in this session, it
* is always searched just after any special namespace.
*
* 3. The system catalog namespace is always searched. If the system
* 2. The system catalog namespace is always searched. If the system
* namespace is present in the explicit path then it will be searched in
* the specified order; otherwise it will be searched after TEMP tables and
* *before* the explicit list. (It might seem that the system namespace
@ -63,43 +62,67 @@
* SQL99. Also, this provides a way to search the system namespace first
* without thereby making it the default creation target namespace.)
*
* The default creation target namespace is normally equal to the first
* element of the explicit list, but is the "special" namespace when one
* has been set. If the explicit list is empty and there is no special
* namespace, there is no default target.
* The default creation target namespace is always the first element of the
* explicit list. If the explicit list is empty, there is no default target.
*
* In bootstrap mode, the search path is set equal to 'pg_catalog', so that
* the system namespace is the only one searched or inserted into.
* The initdb script is also careful to set search_path to 'pg_catalog' for
* its post-bootstrap standalone backend runs. Otherwise the default search
* initdb is also careful to set search_path to 'pg_catalog' for its
* post-bootstrap standalone backend runs. Otherwise the default search
* path is determined by GUC. The factory default path contains the PUBLIC
* namespace (if it exists), preceded by the user's personal namespace
* (if one exists).
*
* If namespaceSearchPathValid is false, then namespaceSearchPath (and other
* We support a stack of "override" search path settings for use within
* specific sections of backend code. namespace_search_path is ignored
* whenever the override stack is nonempty. activeSearchPath is always
* the actually active path; it points either to the search list of the
* topmost stack entry, or to baseSearchPath which is the list derived
* from namespace_search_path.
*
* If baseSearchPathValid is false, then baseSearchPath (and other
* derived variables) need to be recomputed from namespace_search_path.
* We mark it invalid upon an assignment to namespace_search_path or receipt
* of a syscache invalidation event for pg_namespace. The recomputation
* is done during the next lookup attempt.
* is done during the next non-overridden lookup attempt. Note that an
* override spec is never subject to recomputation.
*
* Any namespaces mentioned in namespace_search_path that are not readable
* by the current user ID are simply left out of namespaceSearchPath; so
* by the current user ID are simply left out of baseSearchPath; so
* we have to be willing to recompute the path when current userid changes.
* namespaceUser is the userid the path has been computed for.
*
* Note: all data pointed to by these List variables is in TopMemoryContext.
*/
static List *namespaceSearchPath = NIL;
/* These variables define the actually active state: */
static Oid namespaceUser = InvalidOid;
static List *activeSearchPath = NIL;
/* default place to create stuff; if InvalidOid, no default */
static Oid defaultCreationNamespace = InvalidOid;
static Oid activeCreationNamespace = InvalidOid;
/* first explicit member of list; usually same as defaultCreationNamespace */
static Oid firstExplicitNamespace = InvalidOid;
/* These variables are the values last derived from namespace_search_path: */
/* The above four values are valid only if namespaceSearchPathValid */
static bool namespaceSearchPathValid = true;
static List *baseSearchPath = NIL;
static Oid baseCreationNamespace = InvalidOid;
static Oid namespaceUser = InvalidOid;
/* The above three values are valid only if baseSearchPathValid */
static bool baseSearchPathValid = true;
/* Override requests are remembered in a stack of OverrideStackEntry structs */
typedef struct
{
List *searchPath; /* the desired search path */
Oid creationNamespace; /* the desired creation namespace */
int nestLevel; /* subtransaction nesting level */
} OverrideStackEntry;
static List *overrideStack = NIL;
/*
* myTempNamespace is InvalidOid until and unless a TEMP namespace is set up
@ -118,13 +141,7 @@ static Oid myTempNamespace = InvalidOid;
static SubTransactionId myTempNamespaceSubID = InvalidSubTransactionId;
/*
* "Special" namespace for CREATE SCHEMA. If set, it's the first search
* path element, and also the default creation namespace.
*/
static Oid mySpecialNamespace = InvalidOid;
/*
* This is the text equivalent of the search path --- it's the value
* This is the user's textual search path specification --- it's the value
* of the GUC variable 'search_path'.
*/
char *namespace_search_path = NULL;
@ -260,7 +277,7 @@ RangeVarGetCreationNamespace(const RangeVar *newRelation)
{
/* use the default creation namespace */
recomputeNamespacePath();
namespaceId = defaultCreationNamespace;
namespaceId = activeCreationNamespace;
if (!OidIsValid(namespaceId))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_SCHEMA),
@ -285,7 +302,7 @@ RelnameGetRelid(const char *relname)
recomputeNamespacePath();
foreach(l, namespaceSearchPath)
foreach(l, activeSearchPath)
{
Oid namespaceId = lfirst_oid(l);
@ -329,7 +346,7 @@ RelationIsVisible(Oid relid)
*/
relnamespace = relform->relnamespace;
if (relnamespace != PG_CATALOG_NAMESPACE &&
!list_member_oid(namespaceSearchPath, relnamespace))
!list_member_oid(activeSearchPath, relnamespace))
visible = false;
else
{
@ -342,7 +359,7 @@ RelationIsVisible(Oid relid)
ListCell *l;
visible = false;
foreach(l, namespaceSearchPath)
foreach(l, activeSearchPath)
{
Oid namespaceId = lfirst_oid(l);
@ -381,7 +398,7 @@ TypenameGetTypid(const char *typname)
recomputeNamespacePath();
foreach(l, namespaceSearchPath)
foreach(l, activeSearchPath)
{
Oid namespaceId = lfirst_oid(l);
@ -427,7 +444,7 @@ TypeIsVisible(Oid typid)
*/
typnamespace = typform->typnamespace;
if (typnamespace != PG_CATALOG_NAMESPACE &&
!list_member_oid(namespaceSearchPath, typnamespace))
!list_member_oid(activeSearchPath, typnamespace))
visible = false;
else
{
@ -440,7 +457,7 @@ TypeIsVisible(Oid typid)
ListCell *l;
visible = false;
foreach(l, namespaceSearchPath)
foreach(l, activeSearchPath)
{
Oid namespaceId = lfirst_oid(l);
@ -535,7 +552,7 @@ FuncnameGetCandidates(List *names, int nargs)
/* Consider only procs that are in the search path */
ListCell *nsp;
foreach(nsp, namespaceSearchPath)
foreach(nsp, activeSearchPath)
{
if (procform->pronamespace == lfirst_oid(nsp))
break;
@ -647,7 +664,7 @@ FunctionIsVisible(Oid funcid)
*/
pronamespace = procform->pronamespace;
if (pronamespace != PG_CATALOG_NAMESPACE &&
!list_member_oid(namespaceSearchPath, pronamespace))
!list_member_oid(activeSearchPath, pronamespace))
visible = false;
else
{
@ -748,7 +765,7 @@ OpernameGetOprid(List *names, Oid oprleft, Oid oprright)
*/
recomputeNamespacePath();
foreach(l, namespaceSearchPath)
foreach(l, activeSearchPath)
{
Oid namespaceId = lfirst_oid(l);
int i;
@ -858,7 +875,7 @@ OpernameGetCandidates(List *names, char oprkind)
/* Consider only opers that are in the search path */
ListCell *nsp;
foreach(nsp, namespaceSearchPath)
foreach(nsp, activeSearchPath)
{
if (operform->oprnamespace == lfirst_oid(nsp))
break;
@ -965,7 +982,7 @@ OperatorIsVisible(Oid oprid)
*/
oprnamespace = oprform->oprnamespace;
if (oprnamespace != PG_CATALOG_NAMESPACE &&
!list_member_oid(namespaceSearchPath, oprnamespace))
!list_member_oid(activeSearchPath, oprnamespace))
visible = false;
else
{
@ -1004,7 +1021,7 @@ OpclassnameGetOpcid(Oid amid, const char *opcname)
recomputeNamespacePath();
foreach(l, namespaceSearchPath)
foreach(l, activeSearchPath)
{
Oid namespaceId = lfirst_oid(l);
@ -1051,7 +1068,7 @@ OpclassIsVisible(Oid opcid)
*/
opcnamespace = opcform->opcnamespace;
if (opcnamespace != PG_CATALOG_NAMESPACE &&
!list_member_oid(namespaceSearchPath, opcnamespace))
!list_member_oid(activeSearchPath, opcnamespace))
visible = false;
else
{
@ -1087,7 +1104,7 @@ OpfamilynameGetOpfid(Oid amid, const char *opfname)
recomputeNamespacePath();
foreach(l, namespaceSearchPath)
foreach(l, activeSearchPath)
{
Oid namespaceId = lfirst_oid(l);
@ -1134,7 +1151,7 @@ OpfamilyIsVisible(Oid opfid)
*/
opfnamespace = opfform->opfnamespace;
if (opfnamespace != PG_CATALOG_NAMESPACE &&
!list_member_oid(namespaceSearchPath, opfnamespace))
!list_member_oid(activeSearchPath, opfnamespace))
visible = false;
else
{
@ -1169,7 +1186,7 @@ ConversionGetConid(const char *conname)
recomputeNamespacePath();
foreach(l, namespaceSearchPath)
foreach(l, activeSearchPath)
{
Oid namespaceId = lfirst_oid(l);
@ -1215,7 +1232,7 @@ ConversionIsVisible(Oid conid)
*/
connamespace = conform->connamespace;
if (connamespace != PG_CATALOG_NAMESPACE &&
!list_member_oid(namespaceSearchPath, connamespace))
!list_member_oid(activeSearchPath, connamespace))
visible = false;
else
{
@ -1381,7 +1398,7 @@ QualifiedNameGetCreationNamespace(List *names, char **objname_p)
{
/* use the default creation namespace */
recomputeNamespacePath();
namespaceId = defaultCreationNamespace;
namespaceId = activeCreationNamespace;
if (!OidIsValid(namespaceId))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_SCHEMA),
@ -1520,36 +1537,146 @@ isOtherTempNamespace(Oid namespaceId)
return isAnyTempNamespace(namespaceId);
}
/*
* PushSpecialNamespace - push a "special" namespace onto the front of the
* search path.
* GetOverrideSearchPath - fetch current search path definition in form
* used by PushOverrideSearchPath.
*
* This is a slightly messy hack intended only for support of CREATE SCHEMA.
* Although the API is defined to allow a stack of pushed namespaces, we
* presently only support one at a time.
* The result structure is allocated in the specified memory context
* (which might or might not be equal to CurrentMemoryContext); but any
* junk created by revalidation calculations will be in CurrentMemoryContext.
*/
OverrideSearchPath *
GetOverrideSearchPath(MemoryContext context)
{
OverrideSearchPath *result;
List *schemas;
MemoryContext oldcxt;
recomputeNamespacePath();
oldcxt = MemoryContextSwitchTo(context);
result = (OverrideSearchPath *) palloc0(sizeof(OverrideSearchPath));
schemas = list_copy(activeSearchPath);
while (schemas && linitial_oid(schemas) != activeCreationNamespace)
{
if (linitial_oid(schemas) == myTempNamespace)
result->addTemp = true;
else
{
Assert(linitial_oid(schemas) == PG_CATALOG_NAMESPACE);
result->addCatalog = true;
}
schemas = list_delete_first(schemas);
}
result->schemas = schemas;
MemoryContextSwitchTo(oldcxt);
return result;
}
/*
* PushOverrideSearchPath - temporarily override the search path
*
* The pushed namespace will be removed from the search path at end of
* transaction, whether commit or abort.
* We allow nested overrides, hence the push/pop terminology. The GUC
* search_path variable is ignored while an override is active.
*/
void
PushSpecialNamespace(Oid namespaceId)
PushOverrideSearchPath(OverrideSearchPath *newpath)
{
Assert(!OidIsValid(mySpecialNamespace));
mySpecialNamespace = namespaceId;
namespaceSearchPathValid = false;
OverrideStackEntry *entry;
List *oidlist;
Oid firstNS;
MemoryContext oldcxt;
/*
* Copy the list for safekeeping, and insert implicitly-searched
* namespaces as needed. This code should track recomputeNamespacePath.
*/
oldcxt = MemoryContextSwitchTo(TopMemoryContext);
oidlist = list_copy(newpath->schemas);
/*
* Remember the first member of the explicit list.
*/
if (oidlist == NIL)
firstNS = InvalidOid;
else
firstNS = linitial_oid(oidlist);
/*
* Add any implicitly-searched namespaces to the list. Note these go on
* the front, not the back; also notice that we do not check USAGE
* permissions for these.
*/
if (newpath->addCatalog)
oidlist = lcons_oid(PG_CATALOG_NAMESPACE, oidlist);
if (newpath->addTemp)
{
Assert(OidIsValid(myTempNamespace));
oidlist = lcons_oid(myTempNamespace, oidlist);
}
/*
* Build the new stack entry, then insert it at the head of the list.
*/
entry = (OverrideStackEntry *) palloc(sizeof(OverrideStackEntry));
entry->searchPath = oidlist;
entry->creationNamespace = firstNS;
entry->nestLevel = GetCurrentTransactionNestLevel();
overrideStack = lcons(entry, overrideStack);
/* And make it active. */
activeSearchPath = entry->searchPath;
activeCreationNamespace = entry->creationNamespace;
MemoryContextSwitchTo(oldcxt);
}
/*
* PopSpecialNamespace - remove previously pushed special namespace.
* PopOverrideSearchPath - undo a previous PushOverrideSearchPath
*
* Any push during a (sub)transaction will be popped automatically at abort.
* But it's caller error if a push isn't popped in normal control flow.
*/
void
PopSpecialNamespace(Oid namespaceId)
PopOverrideSearchPath(void)
{
Assert(mySpecialNamespace == namespaceId);
mySpecialNamespace = InvalidOid;
namespaceSearchPathValid = false;
OverrideStackEntry *entry;
/* Sanity checks. */
if (overrideStack == NIL)
elog(ERROR, "bogus PopOverrideSearchPath call");
entry = (OverrideStackEntry *) linitial(overrideStack);
if (entry->nestLevel != GetCurrentTransactionNestLevel())
elog(ERROR, "bogus PopOverrideSearchPath call");
/* Pop the stack and free storage. */
overrideStack = list_delete_first(overrideStack);
list_free(entry->searchPath);
pfree(entry);
/* Activate the next level down. */
if (overrideStack)
{
entry = (OverrideStackEntry *) linitial(overrideStack);
activeSearchPath = entry->searchPath;
activeCreationNamespace = entry->creationNamespace;
}
else
{
/* If not baseSearchPathValid, this is useless but harmless */
activeSearchPath = baseSearchPath;
activeCreationNamespace = baseCreationNamespace;
}
}
/*
* FindConversionByName - find a conversion by possibly qualified name
*/
@ -1576,7 +1703,7 @@ FindConversionByName(List *name)
/* search for it in search path */
recomputeNamespacePath();
foreach(l, namespaceSearchPath)
foreach(l, activeSearchPath)
{
namespaceId = lfirst_oid(l);
conoid = FindConversion(conversion_name, namespaceId);
@ -1600,7 +1727,7 @@ FindDefaultConversionProc(int4 for_encoding, int4 to_encoding)
recomputeNamespacePath();
foreach(l, namespaceSearchPath)
foreach(l, activeSearchPath)
{
Oid namespaceId = lfirst_oid(l);
@ -1628,10 +1755,12 @@ recomputeNamespacePath(void)
Oid firstNS;
MemoryContext oldcxt;
/*
* Do nothing if path is already valid.
*/
if (namespaceSearchPathValid && namespaceUser == roleid)
/* Do nothing if an override search spec is active. */
if (overrideStack)
return;
/* Do nothing if path is already valid. */
if (baseSearchPathValid && namespaceUser == roleid)
return;
/* Need a modifiable copy of namespace_search_path string */
@ -1715,10 +1844,6 @@ recomputeNamespacePath(void)
!list_member_oid(oidlist, myTempNamespace))
oidlist = lcons_oid(myTempNamespace, oidlist);
if (OidIsValid(mySpecialNamespace) &&
!list_member_oid(oidlist, mySpecialNamespace))
oidlist = lcons_oid(mySpecialNamespace, oidlist);
/*
* Now that we've successfully built the new list of namespace OIDs, save
* it in permanent storage.
@ -1727,23 +1852,19 @@ recomputeNamespacePath(void)
newpath = list_copy(oidlist);
MemoryContextSwitchTo(oldcxt);
/* Now safe to assign to state variable. */
list_free(namespaceSearchPath);
namespaceSearchPath = newpath;
/*
* Update info derived from search path.
*/
firstExplicitNamespace = firstNS;
if (OidIsValid(mySpecialNamespace))
defaultCreationNamespace = mySpecialNamespace;
else
defaultCreationNamespace = firstNS;
/* Now safe to assign to state variables. */
list_free(baseSearchPath);
baseSearchPath = newpath;
baseCreationNamespace = firstNS;
/* Mark the path valid. */
namespaceSearchPathValid = true;
baseSearchPathValid = true;
namespaceUser = roleid;
/* And make it active. */
activeSearchPath = baseSearchPath;
activeCreationNamespace = baseCreationNamespace;
/* Clean up. */
pfree(rawname);
list_free(namelist);
@ -1816,7 +1937,7 @@ InitTempTableNamespace(void)
AssertState(myTempNamespaceSubID == InvalidSubTransactionId);
myTempNamespaceSubID = GetCurrentSubTransactionId();
namespaceSearchPathValid = false; /* need to rebuild list */
baseSearchPathValid = false; /* need to rebuild list */
}
/*
@ -1840,18 +1961,30 @@ AtEOXact_Namespace(bool isCommit)
else
{
myTempNamespace = InvalidOid;
namespaceSearchPathValid = false; /* need to rebuild list */
baseSearchPathValid = false; /* need to rebuild list */
}
myTempNamespaceSubID = InvalidSubTransactionId;
}
/*
* Clean up if someone failed to do PopSpecialNamespace
* Clean up if someone failed to do PopOverrideSearchPath
*/
if (OidIsValid(mySpecialNamespace))
if (overrideStack)
{
mySpecialNamespace = InvalidOid;
namespaceSearchPathValid = false; /* need to rebuild list */
if (isCommit)
elog(WARNING, "leaked override search path");
while (overrideStack)
{
OverrideStackEntry *entry;
entry = (OverrideStackEntry *) linitial(overrideStack);
overrideStack = list_delete_first(overrideStack);
list_free(entry->searchPath);
pfree(entry);
}
/* If not baseSearchPathValid, this is useless but harmless */
activeSearchPath = baseSearchPath;
activeCreationNamespace = baseCreationNamespace;
}
}
@ -1867,6 +2000,8 @@ void
AtEOSubXact_Namespace(bool isCommit, SubTransactionId mySubid,
SubTransactionId parentSubid)
{
OverrideStackEntry *entry;
if (myTempNamespaceSubID == mySubid)
{
if (isCommit)
@ -1876,9 +2011,38 @@ AtEOSubXact_Namespace(bool isCommit, SubTransactionId mySubid,
myTempNamespaceSubID = InvalidSubTransactionId;
/* TEMP namespace creation failed, so reset state */
myTempNamespace = InvalidOid;
namespaceSearchPathValid = false; /* need to rebuild list */
baseSearchPathValid = false; /* need to rebuild list */
}
}
/*
* Clean up if someone failed to do PopOverrideSearchPath
*/
while (overrideStack)
{
entry = (OverrideStackEntry *) linitial(overrideStack);
if (entry->nestLevel < GetCurrentTransactionNestLevel())
break;
if (isCommit)
elog(WARNING, "leaked override search path");
overrideStack = list_delete_first(overrideStack);
list_free(entry->searchPath);
pfree(entry);
}
/* Activate the next level down. */
if (overrideStack)
{
entry = (OverrideStackEntry *) linitial(overrideStack);
activeSearchPath = entry->searchPath;
activeCreationNamespace = entry->creationNamespace;
}
else
{
/* If not baseSearchPathValid, this is useless but harmless */
activeSearchPath = baseSearchPath;
activeCreationNamespace = baseCreationNamespace;
}
}
/*
@ -1991,7 +2155,7 @@ assign_search_path(const char *newval, bool doit, GucSource source)
* initialization.
*/
if (doit)
namespaceSearchPathValid = false;
baseSearchPathValid = false;
return newval;
}
@ -2013,12 +2177,13 @@ InitializeSearchPath(void)
MemoryContext oldcxt;
oldcxt = MemoryContextSwitchTo(TopMemoryContext);
namespaceSearchPath = list_make1_oid(PG_CATALOG_NAMESPACE);
baseSearchPath = list_make1_oid(PG_CATALOG_NAMESPACE);
MemoryContextSwitchTo(oldcxt);
defaultCreationNamespace = PG_CATALOG_NAMESPACE;
firstExplicitNamespace = PG_CATALOG_NAMESPACE;
namespaceSearchPathValid = true;
baseCreationNamespace = PG_CATALOG_NAMESPACE;
baseSearchPathValid = true;
namespaceUser = GetUserId();
activeSearchPath = baseSearchPath;
activeCreationNamespace = baseCreationNamespace;
}
else
{
@ -2030,7 +2195,7 @@ InitializeSearchPath(void)
NamespaceCallback,
(Datum) 0);
/* Force search path to be recomputed on next use */
namespaceSearchPathValid = false;
baseSearchPathValid = false;
}
}
@ -2042,7 +2207,7 @@ static void
NamespaceCallback(Datum arg, Oid relid)
{
/* Force search path to be recomputed on next use */
namespaceSearchPathValid = false;
baseSearchPathValid = false;
}
/*
@ -2060,10 +2225,10 @@ fetch_search_path(bool includeImplicit)
recomputeNamespacePath();
result = list_copy(namespaceSearchPath);
result = list_copy(activeSearchPath);
if (!includeImplicit)
{
while (result && linitial_oid(result) != firstExplicitNamespace)
while (result && linitial_oid(result) != activeCreationNamespace)
result = list_delete_first(result);
}

10
src/backend/commands/schemacmds.c
Unescape View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/schemacmds.c,v 1.44 2007/03/13 00:33:39 tgl Exp $
* $PostgreSQL: pgsql/src/backend/commands/schemacmds.c,v 1.45 2007/03/23 19:53:51 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -43,6 +43,7 @@ CreateSchemaCommand(CreateSchemaStmt *stmt, const char *queryString)
const char *schemaName = stmt->schemaname;
const char *authId = stmt->authid;
Oid namespaceId;
OverrideSearchPath *overridePath;
List *parsetree_list;
ListCell *parsetree_item;
Oid owner_uid;
@ -102,7 +103,10 @@ CreateSchemaCommand(CreateSchemaStmt *stmt, const char *queryString)
* well as the default creation target namespace. This will be undone at
* the end of this routine, or upon error.
*/
PushSpecialNamespace(namespaceId);
overridePath = GetOverrideSearchPath(CurrentMemoryContext);
overridePath->schemas = lcons_oid(namespaceId, overridePath->schemas);
/* XXX should we clear overridePath->useTemp? */
PushOverrideSearchPath(overridePath);
/*
* Examine the list of commands embedded in the CREATE SCHEMA command, and
@ -143,7 +147,7 @@ CreateSchemaCommand(CreateSchemaStmt *stmt, const char *queryString)
}
/* Reset search path to normal state */
PopSpecialNamespace(namespaceId);
PopOverrideSearchPath();
/* Reset current user */
SetUserId(saved_uid);

28
src/backend/utils/cache/plancache.c vendored
Unescape View File

@ -33,13 +33,14 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/cache/plancache.c,v 1.3 2007/03/19 23:38:29 wieck Exp $
* $PostgreSQL: pgsql/src/backend/utils/cache/plancache.c,v 1.4 2007/03/23 19:53:51 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "utils/plancache.h"
#include "catalog/namespace.h"
#include "executor/executor.h"
#include "optimizer/clauses.h"
#include "storage/lmgr.h"
@ -120,6 +121,7 @@ CreateCachedPlan(Node *raw_parse_tree,
bool fixed_result)
{
CachedPlanSource *plansource;
OverrideSearchPath *search_path;
MemoryContext source_context;
MemoryContext oldcxt;
@ -133,6 +135,12 @@ CreateCachedPlan(Node *raw_parse_tree,
ALLOCSET_SMALL_INITSIZE,
ALLOCSET_SMALL_MAXSIZE);
/*
* Fetch current search_path into new context, but do any recalculation
* work required in caller's context.
*/
search_path = GetOverrideSearchPath(source_context);
/*
* Create and fill the CachedPlanSource struct within the new context.
*/
@ -151,6 +159,7 @@ CreateCachedPlan(Node *raw_parse_tree,
plansource->num_params = num_params;
plansource->fully_planned = fully_planned;
plansource->fixed_result = fixed_result;
plansource->search_path = search_path;
plansource->generation = 0; /* StoreCachedPlan will increment */
plansource->resultDesc = PlanCacheComputeResultDesc(stmt_list);
plansource->plan = NULL;
@ -209,8 +218,15 @@ FastCreateCachedPlan(Node *raw_parse_tree,
MemoryContext context)
{
CachedPlanSource *plansource;
OverrideSearchPath *search_path;
MemoryContext oldcxt;
/*
* Fetch current search_path into given context, but do any recalculation
* work required in caller's context.
*/
search_path = GetOverrideSearchPath(context);
/*
* Create and fill the CachedPlanSource struct within the given context.
*/
@ -223,6 +239,7 @@ FastCreateCachedPlan(Node *raw_parse_tree,
plansource->num_params = num_params;
plansource->fully_planned = fully_planned;
plansource->fixed_result = fixed_result;
plansource->search_path = search_path;
plansource->generation = 0; /* StoreCachedPlan will increment */
plansource->resultDesc = PlanCacheComputeResultDesc(stmt_list);
plansource->plan = NULL;
@ -420,6 +437,12 @@ RevalidateCachedPlan(CachedPlanSource *plansource, bool useResOwner)
List *slist;
TupleDesc resultDesc;
/*
* Restore the search_path that was in use when the plan was made.
* (XXX is there anything else we really need to restore?)
*/
PushOverrideSearchPath(plansource->search_path);
/*
* Run parse analysis and rule rewriting. The parser tends to
* scribble on its input, so we must copy the raw parse tree to
@ -469,6 +492,9 @@ RevalidateCachedPlan(CachedPlanSource *plansource, bool useResOwner)
MemoryContextSwitchTo(oldcxt);
}
/* Now we can restore current search path */
PopOverrideSearchPath();
/*
* Store the plans into the plancache entry, advancing the generation
* count.

17
src/include/catalog/namespace.h
Unescape View File

@ -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/include/catalog/namespace.h,v 1.44 2007/01/05 22:19:52 momjian Exp $
* $PostgreSQL: pgsql/src/include/catalog/namespace.h,v 1.45 2007/03/23 19:53:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -32,6 +32,16 @@ typedef struct _FuncCandidateList
Oid args[1]; /* arg types --- VARIABLE LENGTH ARRAY */
} *FuncCandidateList; /* VARIABLE LENGTH STRUCT */
/*
* Structure for xxxOverrideSearchPath functions
*/
typedef struct OverrideSearchPath
{
List *schemas; /* OIDs of explicitly named schemas */
bool addCatalog; /* implicitly prepend pg_catalog? */
bool addTemp; /* implicitly prepend temp schema? */
} OverrideSearchPath;
extern Oid RangeVarGetRelid(const RangeVar *relation, bool failOK);
extern Oid RangeVarGetCreationNamespace(const RangeVar *newRelation);
@ -72,8 +82,9 @@ extern bool isTempNamespace(Oid namespaceId);
extern bool isAnyTempNamespace(Oid namespaceId);
extern bool isOtherTempNamespace(Oid namespaceId);
extern void PushSpecialNamespace(Oid namespaceId);
extern void PopSpecialNamespace(Oid namespaceId);
extern OverrideSearchPath *GetOverrideSearchPath(MemoryContext context);
extern void PushOverrideSearchPath(OverrideSearchPath *newpath);
extern void PopOverrideSearchPath(void);
extern Oid FindConversionByName(List *conname);
extern Oid FindDefaultConversionProc(int4 for_encoding, int4 to_encoding);

3
src/include/utils/plancache.h
Unescape View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* $PostgreSQL: pgsql/src/include/utils/plancache.h,v 1.3 2007/03/19 23:38:32 wieck Exp $
* $PostgreSQL: pgsql/src/include/utils/plancache.h,v 1.4 2007/03/23 19:53:52 tgl Exp $
*
*-------------------------------------------------------------------------
*/
@ -53,6 +53,7 @@ typedef struct CachedPlanSource
int num_params; /* length of param_types array */
bool fully_planned; /* do we cache planner or rewriter output? */
bool fixed_result; /* disallow change in result tupdesc? */
struct OverrideSearchPath *search_path; /* saved search_path */
int generation; /* counter, starting at 1, for replans */
TupleDesc resultDesc; /* result type; NULL = doesn't return tuples */
struct CachedPlan *plan; /* link to plan, or NULL if not valid */

39
src/test/regress/expected/plancache.out
Unescape View File

@ -163,3 +163,42 @@ select cache_test_2();
10007
(1 row)
--- Check that change of search_path is ignored by replans
create schema s1
create table abc (f1 int);
create schema s2
create table abc (f1 int);
insert into s1.abc values(123);
insert into s2.abc values(456);
set search_path = s1;
prepare p1 as select f1 from abc;
execute p1;
f1
-----
123
(1 row)
set search_path = s2;
select f1 from abc;
f1
-----
456
(1 row)
execute p1;
f1
-----
123
(1 row)
alter table s1.abc add column f2 float8; -- force replan
execute p1;
f1
-----
123
(1 row)
drop schema s1 cascade;
NOTICE: drop cascades to table s1.abc
drop schema s2 cascade;
NOTICE: drop cascades to table abc

30
src/test/regress/sql/plancache.sql
Unescape View File

@ -93,3 +93,33 @@ select cache_test_2();
create or replace temp view v1 as
select 2+2+4+(select max(unique1) from tenk1) as f1;
select cache_test_2();
--- Check that change of search_path is ignored by replans
create schema s1
create table abc (f1 int);
create schema s2
create table abc (f1 int);
insert into s1.abc values(123);
insert into s2.abc values(456);
set search_path = s1;
prepare p1 as select f1 from abc;
execute p1;
set search_path = s2;
select f1 from abc;
execute p1;
alter table s1.abc add column f2 float8; -- force replan
execute p1;
drop schema s1 cascade;
drop schema s2 cascade;

Write Preview
Loading…
Cancel
Save