granicus.if.org Git - postgresql/blob - src/backend/catalog/namespace.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * namespace.c
   4  *        code to support accessing and searching namespaces
   5  *
   6  * This is separate from pg_namespace.c, which contains the routines that
   7  * directly manipulate the pg_namespace system catalog.  This module
   8  * provides routines associated with defining a "namespace search path"
   9  * and implementing search-path-controlled searches.
  10  *
  11  *
  12  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  13  * Portions Copyright (c) 1994, Regents of the University of California
  14  *
  15  * IDENTIFICATION
  16  *        $Header: /cvsroot/pgsql/src/backend/catalog/namespace.c,v 1.41 2002/12/04 05:18:31 momjian Exp $
  17  *
  18  *-------------------------------------------------------------------------
  19  */
  20 #include "postgres.h"
  21
  22 #include "access/heapam.h"
  23 #include "access/xact.h"
  24 #include "catalog/catalog.h"
  25 #include "catalog/catname.h"
  26 #include "catalog/dependency.h"
  27 #include "catalog/heap.h"
  28 #include "catalog/namespace.h"
  29 #include "catalog/pg_conversion.h"
  30 #include "catalog/pg_inherits.h"
  31 #include "catalog/pg_namespace.h"
  32 #include "catalog/pg_opclass.h"
  33 #include "catalog/pg_operator.h"
  34 #include "catalog/pg_proc.h"
  35 #include "catalog/pg_shadow.h"
  36 #include "catalog/pg_type.h"
  37 #include "lib/stringinfo.h"
  38 #include "miscadmin.h"
  39 #include "nodes/makefuncs.h"
  40 #include "storage/backendid.h"
  41 #include "storage/ipc.h"
  42 #include "utils/acl.h"
  43 #include "utils/builtins.h"
  44 #include "utils/catcache.h"
  45 #include "utils/fmgroids.h"
  46 #include "utils/guc.h"
  47 #include "utils/inval.h"
  48 #include "utils/lsyscache.h"
  49 #include "utils/syscache.h"
  50
  51
  52 /*
  53  * The namespace search path is a possibly-empty list of namespace OIDs.
  54  * In addition to the explicit list, several implicitly-searched namespaces
  55  * may be included:
  56  *
  57  * 1. If a "special" namespace has been set by PushSpecialNamespace, it is
  58  * always searched first.  (This is a hack for CREATE SCHEMA.)
  59  *
  60  * 2. If a TEMP table namespace has been initialized in this session, it
  61  * is always searched just after any special namespace.
  62  *
  63  * 3. The system catalog namespace is always searched.  If the system
  64  * namespace is present in the explicit path then it will be searched in
  65  * the specified order; otherwise it will be searched after TEMP tables and
  66  * *before* the explicit list.  (It might seem that the system namespace
  67  * should be implicitly last, but this behavior appears to be required by
  68  * SQL99.  Also, this provides a way to search the system namespace first
  69  * without thereby making it the default creation target namespace.)
  70  *
  71  * The default creation target namespace is normally equal to the first
  72  * element of the explicit list, but is the "special" namespace when one
  73  * has been set.  If the explicit list is empty and there is no special
  74  * namespace, there is no default target.
  75  *
  76  * In bootstrap mode, the search path is set equal to 'pg_catalog', so that
  77  * the system namespace is the only one searched or inserted into.
  78  * The initdb script is also careful to set search_path to 'pg_catalog' for
  79  * its post-bootstrap standalone backend runs.  Otherwise the default search
  80  * path is determined by GUC.  The factory default path contains the PUBLIC
  81  * namespace (if it exists), preceded by the user's personal namespace
  82  * (if one exists).
  83  *
  84  * If namespaceSearchPathValid is false, then namespaceSearchPath (and other
  85  * derived variables) need to be recomputed from namespace_search_path.
  86  * We mark it invalid upon an assignment to namespace_search_path or receipt
  87  * of a syscache invalidation event for pg_namespace.  The recomputation
  88  * is done during the next lookup attempt.
  89  *
  90  * Any namespaces mentioned in namespace_search_path that are not readable
  91  * by the current user ID are simply left out of namespaceSearchPath; so
  92  * we have to be willing to recompute the path when current userid changes.
  93  * namespaceUser is the userid the path has been computed for.
  94  */
  95
  96 static List *namespaceSearchPath = NIL;
  97
  98 static Oid      namespaceUser = InvalidOid;
  99
 100 /* default place to create stuff; if InvalidOid, no default */
 101 static Oid      defaultCreationNamespace = InvalidOid;
 102
 103 /* first explicit member of list; usually same as defaultCreationNamespace */
 104 static Oid      firstExplicitNamespace = InvalidOid;
 105
 106 /* The above four values are valid only if namespaceSearchPathValid */
 107 static bool namespaceSearchPathValid = true;
 108
 109 /*
 110  * myTempNamespace is InvalidOid until and unless a TEMP namespace is set up
 111  * in a particular backend session (this happens when a CREATE TEMP TABLE
 112  * command is first executed).  Thereafter it's the OID of the temp namespace.
 113  * firstTempTransaction flags whether we've committed creation of the TEMP
 114  * namespace or not.
 115  */
 116 static Oid      myTempNamespace = InvalidOid;
 117
 118 static bool firstTempTransaction = false;
 119
 120 /*
 121  * "Special" namespace for CREATE SCHEMA.  If set, it's the first search
 122  * path element, and also the default creation namespace.
 123  */
 124 static Oid      mySpecialNamespace = InvalidOid;
 125
 126 /*
 127  * This is the text equivalent of the search path --- it's the value
 128  * of the GUC variable 'search_path'.
 129  */
 130 char       *namespace_search_path = NULL;
 131
 132
 133 /* Local functions */
 134 static void recomputeNamespacePath(void);
 135 static void InitTempTableNamespace(void);
 136 static void RemoveTempRelations(Oid tempNamespaceId);
 137 static void RemoveTempRelationsCallback(void);
 138 static void NamespaceCallback(Datum arg, Oid relid);
 139
 140 /* These don't really need to appear in any header file */
 141 Datum           pg_table_is_visible(PG_FUNCTION_ARGS);
 142 Datum           pg_type_is_visible(PG_FUNCTION_ARGS);
 143 Datum           pg_function_is_visible(PG_FUNCTION_ARGS);
 144 Datum           pg_operator_is_visible(PG_FUNCTION_ARGS);
 145 Datum           pg_opclass_is_visible(PG_FUNCTION_ARGS);
 146
 147
 148 /*
 149  * RangeVarGetRelid
 150  *              Given a RangeVar describing an existing relation,
 151  *              select the proper namespace and look up the relation OID.
 152  *
 153  * If the relation is not found, return InvalidOid if failOK = true,
 154  * otherwise raise an error.
 155  */
 156 Oid
 157 RangeVarGetRelid(const RangeVar *relation, bool failOK)
 158 {
 159         Oid                     namespaceId;
 160         Oid                     relId;
 161
 162         /*
 163          * We check the catalog name and then ignore it.
 164          */
 165         if (relation->catalogname)
 166         {
 167                 if (strcmp(relation->catalogname, DatabaseName) != 0)
 168                         elog(ERROR, "Cross-database references are not implemented");
 169         }
 170
 171         if (relation->schemaname)
 172         {
 173                 /* use exact schema given */
 174                 namespaceId = LookupExplicitNamespace(relation->schemaname);
 175                 relId = get_relname_relid(relation->relname, namespaceId);
 176         }
 177         else
 178         {
 179                 /* search the namespace path */
 180                 relId = RelnameGetRelid(relation->relname);
 181         }
 182
 183         if (!OidIsValid(relId) && !failOK)
 184         {
 185                 if (relation->schemaname)
 186                         elog(ERROR, "Relation \"%s\".\"%s\" does not exist",
 187                                  relation->schemaname, relation->relname);
 188                 else
 189                         elog(ERROR, "Relation \"%s\" does not exist",
 190                                  relation->relname);
 191         }
 192         return relId;
 193 }
 194
 195 /*
 196  * RangeVarGetCreationNamespace
 197  *              Given a RangeVar describing a to-be-created relation,
 198  *              choose which namespace to create it in.
 199  *
 200  * Note: calling this may result in a CommandCounterIncrement operation.
 201  * That will happen on the first request for a temp table in any particular
 202  * backend run; we will need to either create or clean out the temp schema.
 203  */
 204 Oid
 205 RangeVarGetCreationNamespace(const RangeVar *newRelation)
 206 {
 207         Oid                     namespaceId;
 208
 209         /*
 210          * We check the catalog name and then ignore it.
 211          */
 212         if (newRelation->catalogname)
 213         {
 214                 if (strcmp(newRelation->catalogname, DatabaseName) != 0)
 215                         elog(ERROR, "Cross-database references are not implemented");
 216         }
 217
 218         if (newRelation->istemp)
 219         {
 220                 /* TEMP tables are created in our backend-local temp namespace */
 221                 if (newRelation->schemaname)
 222                         elog(ERROR, "TEMP tables may not specify a namespace");
 223                 /* Initialize temp namespace if first time through */
 224                 if (!OidIsValid(myTempNamespace))
 225                         InitTempTableNamespace();
 226                 return myTempNamespace;
 227         }
 228
 229         if (newRelation->schemaname)
 230         {
 231                 /* use exact schema given */
 232                 namespaceId = GetSysCacheOid(NAMESPACENAME,
 233                                                                 CStringGetDatum(newRelation->schemaname),
 234                                                                          0, 0, 0);
 235                 if (!OidIsValid(namespaceId))
 236                         elog(ERROR, "Namespace \"%s\" does not exist",
 237                                  newRelation->schemaname);
 238                 /* we do not check for USAGE rights here! */
 239         }
 240         else
 241         {
 242                 /* use the default creation namespace */
 243                 recomputeNamespacePath();
 244                 namespaceId = defaultCreationNamespace;
 245                 if (!OidIsValid(namespaceId))
 246                         elog(ERROR, "No namespace has been selected to create in");
 247         }
 248
 249         /* Note: callers will check for CREATE rights when appropriate */
 250
 251         return namespaceId;
 252 }
 253
 254 /*
 255  * RelnameGetRelid
 256  *              Try to resolve an unqualified relation name.
 257  *              Returns OID if relation found in search path, else InvalidOid.
 258  */
 259 Oid
 260 RelnameGetRelid(const char *relname)
 261 {
 262         Oid                     relid;
 263         List       *lptr;
 264
 265         recomputeNamespacePath();
 266
 267         foreach(lptr, namespaceSearchPath)
 268         {
 269                 Oid                     namespaceId = (Oid) lfirsti(lptr);
 270
 271                 relid = get_relname_relid(relname, namespaceId);
 272                 if (OidIsValid(relid))
 273                         return relid;
 274         }
 275
 276         /* Not found in path */
 277         return InvalidOid;
 278 }
 279
 280 /*
 281  * RelationIsVisible
 282  *              Determine whether a relation (identified by OID) is visible in the
 283  *              current search path.  Visible means "would be found by searching
 284  *              for the unqualified relation name".
 285  */
 286 bool
 287 RelationIsVisible(Oid relid)
 288 {
 289         HeapTuple       reltup;
 290         Form_pg_class relform;
 291         Oid                     relnamespace;
 292         bool            visible;
 293
 294         reltup = SearchSysCache(RELOID,
 295                                                         ObjectIdGetDatum(relid),
 296                                                         0, 0, 0);
 297         if (!HeapTupleIsValid(reltup))
 298                 elog(ERROR, "Cache lookup failed for relation %u", relid);
 299         relform = (Form_pg_class) GETSTRUCT(reltup);
 300
 301         recomputeNamespacePath();
 302
 303         /*
 304          * Quick check: if it ain't in the path at all, it ain't visible.
 305          * Items in the system namespace are surely in the path and so we
 306          * needn't even do intMember() for them.
 307          */
 308         relnamespace = relform->relnamespace;
 309         if (relnamespace != PG_CATALOG_NAMESPACE &&
 310                 !intMember(relnamespace, namespaceSearchPath))
 311                 visible = false;
 312         else
 313         {
 314                 /*
 315                  * If it is in the path, it might still not be visible; it could
 316                  * be hidden by another relation of the same name earlier in the
 317                  * path. So we must do a slow check to see if this rel would be
 318                  * found by RelnameGetRelid.
 319                  */
 320                 char       *relname = NameStr(relform->relname);
 321
 322                 visible = (RelnameGetRelid(relname) == relid);
 323         }
 324
 325         ReleaseSysCache(reltup);
 326
 327         return visible;
 328 }
 329
 330
 331 /*
 332  * TypenameGetTypid
 333  *              Try to resolve an unqualified datatype name.
 334  *              Returns OID if type found in search path, else InvalidOid.
 335  *
 336  * This is essentially the same as RelnameGetRelid.
 337  */
 338 Oid
 339 TypenameGetTypid(const char *typname)
 340 {
 341         Oid                     typid;
 342         List       *lptr;
 343
 344         recomputeNamespacePath();
 345
 346         foreach(lptr, namespaceSearchPath)
 347         {
 348                 Oid                     namespaceId = (Oid) lfirsti(lptr);
 349
 350                 typid = GetSysCacheOid(TYPENAMENSP,
 351                                                            PointerGetDatum(typname),
 352                                                            ObjectIdGetDatum(namespaceId),
 353                                                            0, 0);
 354                 if (OidIsValid(typid))
 355                         return typid;
 356         }
 357
 358         /* Not found in path */
 359         return InvalidOid;
 360 }
 361
 362 /*
 363  * TypeIsVisible
 364  *              Determine whether a type (identified by OID) is visible in the
 365  *              current search path.  Visible means "would be found by searching
 366  *              for the unqualified type name".
 367  */
 368 bool
 369 TypeIsVisible(Oid typid)
 370 {
 371         HeapTuple       typtup;
 372         Form_pg_type typform;
 373         Oid                     typnamespace;
 374         bool            visible;
 375
 376         typtup = SearchSysCache(TYPEOID,
 377                                                         ObjectIdGetDatum(typid),
 378                                                         0, 0, 0);
 379         if (!HeapTupleIsValid(typtup))
 380                 elog(ERROR, "Cache lookup failed for type %u", typid);
 381         typform = (Form_pg_type) GETSTRUCT(typtup);
 382
 383         recomputeNamespacePath();
 384
 385         /*
 386          * Quick check: if it ain't in the path at all, it ain't visible.
 387          * Items in the system namespace are surely in the path and so we
 388          * needn't even do intMember() for them.
 389          */
 390         typnamespace = typform->typnamespace;
 391         if (typnamespace != PG_CATALOG_NAMESPACE &&
 392                 !intMember(typnamespace, namespaceSearchPath))
 393                 visible = false;
 394         else
 395         {
 396                 /*
 397                  * If it is in the path, it might still not be visible; it could
 398                  * be hidden by another type of the same name earlier in the path.
 399                  * So we must do a slow check to see if this type would be found
 400                  * by TypenameGetTypid.
 401                  */
 402                 char       *typname = NameStr(typform->typname);
 403
 404                 visible = (TypenameGetTypid(typname) == typid);
 405         }
 406
 407         ReleaseSysCache(typtup);
 408
 409         return visible;
 410 }
 411
 412
 413 /*
 414  * FuncnameGetCandidates
 415  *              Given a possibly-qualified function name and argument count,
 416  *              retrieve a list of the possible matches.
 417  *
 418  * If nargs is -1, we return all functions matching the given name,
 419  * regardless of argument count.
 420  *
 421  * We search a single namespace if the function name is qualified, else
 422  * all namespaces in the search path.  The return list will never contain
 423  * multiple entries with identical argument lists --- in the multiple-
 424  * namespace case, we arrange for entries in earlier namespaces to mask
 425  * identical entries in later namespaces.
 426  */
 427 FuncCandidateList
 428 FuncnameGetCandidates(List *names, int nargs)
 429 {
 430         FuncCandidateList resultList = NULL;
 431         char       *schemaname;
 432         char       *funcname;
 433         Oid                     namespaceId;
 434         CatCList   *catlist;
 435         int                     i;
 436
 437         /* deconstruct the name list */
 438         DeconstructQualifiedName(names, &schemaname, &funcname);
 439
 440         if (schemaname)
 441         {
 442                 /* use exact schema given */
 443                 namespaceId = LookupExplicitNamespace(schemaname);
 444         }
 445         else
 446         {
 447                 /* flag to indicate we need namespace search */
 448                 namespaceId = InvalidOid;
 449                 recomputeNamespacePath();
 450         }
 451
 452         /* Search syscache by name and (optionally) nargs only */
 453         if (nargs >= 0)
 454                 catlist = SearchSysCacheList(PROCNAMENSP, 2,
 455                                                                          CStringGetDatum(funcname),
 456                                                                          Int16GetDatum(nargs),
 457                                                                          0, 0);
 458         else
 459                 catlist = SearchSysCacheList(PROCNAMENSP, 1,
 460                                                                          CStringGetDatum(funcname),
 461                                                                          0, 0, 0);
 462
 463         for (i = 0; i < catlist->n_members; i++)
 464         {
 465                 HeapTuple       proctup = &catlist->members[i]->tuple;
 466                 Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
 467                 int                     pathpos = 0;
 468                 FuncCandidateList newResult;
 469
 470                 nargs = procform->pronargs;
 471
 472                 if (OidIsValid(namespaceId))
 473                 {
 474                         /* Consider only procs in specified namespace */
 475                         if (procform->pronamespace != namespaceId)
 476                                 continue;
 477                         /* No need to check args, they must all be different */
 478                 }
 479                 else
 480                 {
 481                         /* Consider only procs that are in the search path */
 482                         List       *nsp;
 483
 484                         foreach(nsp, namespaceSearchPath)
 485                         {
 486                                 if (procform->pronamespace == (Oid) lfirsti(nsp))
 487                                         break;
 488                                 pathpos++;
 489                         }
 490                         if (nsp == NIL)
 491                                 continue;               /* proc is not in search path */
 492
 493                         /*
 494                          * Okay, it's in the search path, but does it have the same
 495                          * arguments as something we already accepted?  If so, keep
 496                          * only the one that appears earlier in the search path.
 497                          *
 498                          * If we have an ordered list from SearchSysCacheList (the normal
 499                          * case), then any conflicting proc must immediately adjoin
 500                          * this one in the list, so we only need to look at the newest
 501                          * result item.  If we have an unordered list, we have to scan
 502                          * the whole result list.
 503                          */
 504                         if (resultList)
 505                         {
 506                                 FuncCandidateList prevResult;
 507
 508                                 if (catlist->ordered)
 509                                 {
 510                                         if (nargs == resultList->nargs &&
 511                                                 memcmp(procform->proargtypes, resultList->args,
 512                                                            nargs * sizeof(Oid)) == 0)
 513                                                 prevResult = resultList;
 514                                         else
 515                                                 prevResult = NULL;
 516                                 }
 517                                 else
 518                                 {
 519                                         for (prevResult = resultList;
 520                                                  prevResult;
 521                                                  prevResult = prevResult->next)
 522                                         {
 523                                                 if (nargs == prevResult->nargs &&
 524                                                   memcmp(procform->proargtypes, prevResult->args,
 525                                                                  nargs * sizeof(Oid)) == 0)
 526                                                         break;
 527                                         }
 528                                 }
 529                                 if (prevResult)
 530                                 {
 531                                         /* We have a match with a previous result */
 532                                         Assert(pathpos != prevResult->pathpos);
 533                                         if (pathpos > prevResult->pathpos)
 534                                                 continue;               /* keep previous result */
 535                                         /* replace previous result */
 536                                         prevResult->pathpos = pathpos;
 537                                         prevResult->oid = HeapTupleGetOid(proctup);
 538                                         continue;       /* args are same, of course */
 539                                 }
 540                         }
 541                 }
 542
 543                 /*
 544                  * Okay to add it to result list
 545                  */
 546                 newResult = (FuncCandidateList)
 547                         palloc(sizeof(struct _FuncCandidateList) - sizeof(Oid)
 548                                    + nargs * sizeof(Oid));
 549                 newResult->pathpos = pathpos;
 550                 newResult->oid = HeapTupleGetOid(proctup);
 551                 newResult->nargs = nargs;
 552                 memcpy(newResult->args, procform->proargtypes, nargs * sizeof(Oid));
 553
 554                 newResult->next = resultList;
 555                 resultList = newResult;
 556         }
 557
 558         ReleaseSysCacheList(catlist);
 559
 560         return resultList;
 561 }
 562
 563 /*
 564  * FunctionIsVisible
 565  *              Determine whether a function (identified by OID) is visible in the
 566  *              current search path.  Visible means "would be found by searching
 567  *              for the unqualified function name with exact argument matches".
 568  */
 569 bool
 570 FunctionIsVisible(Oid funcid)
 571 {
 572         HeapTuple       proctup;
 573         Form_pg_proc procform;
 574         Oid                     pronamespace;
 575         bool            visible;
 576
 577         proctup = SearchSysCache(PROCOID,
 578                                                          ObjectIdGetDatum(funcid),
 579                                                          0, 0, 0);
 580         if (!HeapTupleIsValid(proctup))
 581                 elog(ERROR, "Cache lookup failed for procedure %u", funcid);
 582         procform = (Form_pg_proc) GETSTRUCT(proctup);
 583
 584         recomputeNamespacePath();
 585
 586         /*
 587          * Quick check: if it ain't in the path at all, it ain't visible.
 588          * Items in the system namespace are surely in the path and so we
 589          * needn't even do intMember() for them.
 590          */
 591         pronamespace = procform->pronamespace;
 592         if (pronamespace != PG_CATALOG_NAMESPACE &&
 593                 !intMember(pronamespace, namespaceSearchPath))
 594                 visible = false;
 595         else
 596         {
 597                 /*
 598                  * If it is in the path, it might still not be visible; it could
 599                  * be hidden by another proc of the same name and arguments
 600                  * earlier in the path.  So we must do a slow check to see if this
 601                  * is the same proc that would be found by FuncnameGetCandidates.
 602                  */
 603                 char       *proname = NameStr(procform->proname);
 604                 int                     nargs = procform->pronargs;
 605                 FuncCandidateList clist;
 606
 607                 visible = false;
 608
 609                 clist = FuncnameGetCandidates(makeList1(makeString(proname)), nargs);
 610
 611                 for (; clist; clist = clist->next)
 612                 {
 613                         if (memcmp(clist->args, procform->proargtypes,
 614                                            nargs * sizeof(Oid)) == 0)
 615                         {
 616                                 /* Found the expected entry; is it the right proc? */
 617                                 visible = (clist->oid == funcid);
 618                                 break;
 619                         }
 620                 }
 621         }
 622
 623         ReleaseSysCache(proctup);
 624
 625         return visible;
 626 }
 627
 628
 629 /*
 630  * OpernameGetCandidates
 631  *              Given a possibly-qualified operator name and operator kind,
 632  *              retrieve a list of the possible matches.
 633  *
 634  * If oprkind is '\0', we return all operators matching the given name,
 635  * regardless of arguments.
 636  *
 637  * We search a single namespace if the operator name is qualified, else
 638  * all namespaces in the search path.  The return list will never contain
 639  * multiple entries with identical argument lists --- in the multiple-
 640  * namespace case, we arrange for entries in earlier namespaces to mask
 641  * identical entries in later namespaces.
 642  *
 643  * The returned items always have two args[] entries --- one or the other
 644  * will be InvalidOid for a prefix or postfix oprkind.  nargs is 2, too.
 645  */
 646 FuncCandidateList
 647 OpernameGetCandidates(List *names, char oprkind)
 648 {
 649         FuncCandidateList resultList = NULL;
 650         char       *schemaname;
 651         char       *opername;
 652         Oid                     namespaceId;
 653         CatCList   *catlist;
 654         int                     i;
 655
 656         /* deconstruct the name list */
 657         DeconstructQualifiedName(names, &schemaname, &opername);
 658
 659         if (schemaname)
 660         {
 661                 /* use exact schema given */
 662                 namespaceId = LookupExplicitNamespace(schemaname);
 663         }
 664         else
 665         {
 666                 /* flag to indicate we need namespace search */
 667                 namespaceId = InvalidOid;
 668                 recomputeNamespacePath();
 669         }
 670
 671         /* Search syscache by name only */
 672         catlist = SearchSysCacheList(OPERNAMENSP, 1,
 673                                                                  CStringGetDatum(opername),
 674                                                                  0, 0, 0);
 675
 676         for (i = 0; i < catlist->n_members; i++)
 677         {
 678                 HeapTuple       opertup = &catlist->members[i]->tuple;
 679                 Form_pg_operator operform = (Form_pg_operator) GETSTRUCT(opertup);
 680                 int                     pathpos = 0;
 681                 FuncCandidateList newResult;
 682
 683                 /* Ignore operators of wrong kind, if specific kind requested */
 684                 if (oprkind && operform->oprkind != oprkind)
 685                         continue;
 686
 687                 if (OidIsValid(namespaceId))
 688                 {
 689                         /* Consider only opers in specified namespace */
 690                         if (operform->oprnamespace != namespaceId)
 691                                 continue;
 692                         /* No need to check args, they must all be different */
 693                 }
 694                 else
 695                 {
 696                         /* Consider only opers that are in the search path */
 697                         List       *nsp;
 698
 699                         foreach(nsp, namespaceSearchPath)
 700                         {
 701                                 if (operform->oprnamespace == (Oid) lfirsti(nsp))
 702                                         break;
 703                                 pathpos++;
 704                         }
 705                         if (nsp == NIL)
 706                                 continue;               /* oper is not in search path */
 707
 708                         /*
 709                          * Okay, it's in the search path, but does it have the same
 710                          * arguments as something we already accepted?  If so, keep
 711                          * only the one that appears earlier in the search path.
 712                          *
 713                          * If we have an ordered list from SearchSysCacheList (the normal
 714                          * case), then any conflicting oper must immediately adjoin
 715                          * this one in the list, so we only need to look at the newest
 716                          * result item.  If we have an unordered list, we have to scan
 717                          * the whole result list.
 718                          */
 719                         if (resultList)
 720                         {
 721                                 FuncCandidateList prevResult;
 722
 723                                 if (catlist->ordered)
 724                                 {
 725                                         if (operform->oprleft == resultList->args[0] &&
 726                                                 operform->oprright == resultList->args[1])
 727                                                 prevResult = resultList;
 728                                         else
 729                                                 prevResult = NULL;
 730                                 }
 731                                 else
 732                                 {
 733                                         for (prevResult = resultList;
 734                                                  prevResult;
 735                                                  prevResult = prevResult->next)
 736                                         {
 737                                                 if (operform->oprleft == prevResult->args[0] &&
 738                                                         operform->oprright == prevResult->args[1])
 739                                                         break;
 740                                         }
 741                                 }
 742                                 if (prevResult)
 743                                 {
 744                                         /* We have a match with a previous result */
 745                                         Assert(pathpos != prevResult->pathpos);
 746                                         if (pathpos > prevResult->pathpos)
 747                                                 continue;               /* keep previous result */
 748                                         /* replace previous result */
 749                                         prevResult->pathpos = pathpos;
 750                                         prevResult->oid = HeapTupleGetOid(opertup);
 751                                         continue;       /* args are same, of course */
 752                                 }
 753                         }
 754                 }
 755
 756                 /*
 757                  * Okay to add it to result list
 758                  */
 759                 newResult = (FuncCandidateList)
 760                         palloc(sizeof(struct _FuncCandidateList) + sizeof(Oid));
 761                 newResult->pathpos = pathpos;
 762                 newResult->oid = HeapTupleGetOid(opertup);
 763                 newResult->nargs = 2;
 764                 newResult->args[0] = operform->oprleft;
 765                 newResult->args[1] = operform->oprright;
 766                 newResult->next = resultList;
 767                 resultList = newResult;
 768         }
 769
 770         ReleaseSysCacheList(catlist);
 771
 772         return resultList;
 773 }
 774
 775 /*
 776  * OperatorIsVisible
 777  *              Determine whether an operator (identified by OID) is visible in the
 778  *              current search path.  Visible means "would be found by searching
 779  *              for the unqualified operator name with exact argument matches".
 780  */
 781 bool
 782 OperatorIsVisible(Oid oprid)
 783 {
 784         HeapTuple       oprtup;
 785         Form_pg_operator oprform;
 786         Oid                     oprnamespace;
 787         bool            visible;
 788
 789         oprtup = SearchSysCache(OPEROID,
 790                                                         ObjectIdGetDatum(oprid),
 791                                                         0, 0, 0);
 792         if (!HeapTupleIsValid(oprtup))
 793                 elog(ERROR, "Cache lookup failed for operator %u", oprid);
 794         oprform = (Form_pg_operator) GETSTRUCT(oprtup);
 795
 796         recomputeNamespacePath();
 797
 798         /*
 799          * Quick check: if it ain't in the path at all, it ain't visible.
 800          * Items in the system namespace are surely in the path and so we
 801          * needn't even do intMember() for them.
 802          */
 803         oprnamespace = oprform->oprnamespace;
 804         if (oprnamespace != PG_CATALOG_NAMESPACE &&
 805                 !intMember(oprnamespace, namespaceSearchPath))
 806                 visible = false;
 807         else
 808         {
 809                 /*
 810                  * If it is in the path, it might still not be visible; it could
 811                  * be hidden by another operator of the same name and arguments
 812                  * earlier in the path.  So we must do a slow check to see if this
 813                  * is the same operator that would be found by
 814                  * OpernameGetCandidates.
 815                  */
 816                 char       *oprname = NameStr(oprform->oprname);
 817                 FuncCandidateList clist;
 818
 819                 visible = false;
 820
 821                 clist = OpernameGetCandidates(makeList1(makeString(oprname)),
 822                                                                           oprform->oprkind);
 823
 824                 for (; clist; clist = clist->next)
 825                 {
 826                         if (clist->args[0] == oprform->oprleft &&
 827                                 clist->args[1] == oprform->oprright)
 828                         {
 829                                 /* Found the expected entry; is it the right op? */
 830                                 visible = (clist->oid == oprid);
 831                                 break;
 832                         }
 833                 }
 834         }
 835
 836         ReleaseSysCache(oprtup);
 837
 838         return visible;
 839 }
 840
 841
 842 /*
 843  * OpclassGetCandidates
 844  *              Given an index access method OID, retrieve a list of all the
 845  *              opclasses for that AM that are visible in the search path.
 846  *
 847  * NOTE: the opcname_tmp field in the returned structs should not be used
 848  * by callers, because it points at syscache entries that we release at
 849  * the end of this routine.  If any callers needed the name information,
 850  * we could pstrdup() the names ... but at present it'd be wasteful.
 851  */
 852 OpclassCandidateList
 853 OpclassGetCandidates(Oid amid)
 854 {
 855         OpclassCandidateList resultList = NULL;
 856         CatCList   *catlist;
 857         int                     i;
 858
 859         /* Search syscache by AM OID only */
 860         catlist = SearchSysCacheList(CLAAMNAMENSP, 1,
 861                                                                  ObjectIdGetDatum(amid),
 862                                                                  0, 0, 0);
 863
 864         recomputeNamespacePath();
 865
 866         for (i = 0; i < catlist->n_members; i++)
 867         {
 868                 HeapTuple       opctup = &catlist->members[i]->tuple;
 869                 Form_pg_opclass opcform = (Form_pg_opclass) GETSTRUCT(opctup);
 870                 int                     pathpos = 0;
 871                 OpclassCandidateList newResult;
 872                 List       *nsp;
 873
 874                 /* Consider only opclasses that are in the search path */
 875                 foreach(nsp, namespaceSearchPath)
 876                 {
 877                         if (opcform->opcnamespace == (Oid) lfirsti(nsp))
 878                                 break;
 879                         pathpos++;
 880                 }
 881                 if (nsp == NIL)
 882                         continue;                       /* opclass is not in search path */
 883
 884                 /*
 885                  * Okay, it's in the search path, but does it have the same name
 886                  * as something we already accepted?  If so, keep only the one
 887                  * that appears earlier in the search path.
 888                  *
 889                  * If we have an ordered list from SearchSysCacheList (the normal
 890                  * case), then any conflicting opclass must immediately adjoin
 891                  * this one in the list, so we only need to look at the newest
 892                  * result item.  If we have an unordered list, we have to scan the
 893                  * whole result list.
 894                  */
 895                 if (resultList)
 896                 {
 897                         OpclassCandidateList prevResult;
 898
 899                         if (catlist->ordered)
 900                         {
 901                                 if (strcmp(NameStr(opcform->opcname),
 902                                                    resultList->opcname_tmp) == 0)
 903                                         prevResult = resultList;
 904                                 else
 905                                         prevResult = NULL;
 906                         }
 907                         else
 908                         {
 909                                 for (prevResult = resultList;
 910                                          prevResult;
 911                                          prevResult = prevResult->next)
 912                                 {
 913                                         if (strcmp(NameStr(opcform->opcname),
 914                                                            prevResult->opcname_tmp) == 0)
 915                                                 break;
 916                                 }
 917                         }
 918                         if (prevResult)
 919                         {
 920                                 /* We have a match with a previous result */
 921                                 Assert(pathpos != prevResult->pathpos);
 922                                 if (pathpos > prevResult->pathpos)
 923                                         continue;       /* keep previous result */
 924                                 /* replace previous result */
 925                                 prevResult->opcname_tmp = NameStr(opcform->opcname);
 926                                 prevResult->pathpos = pathpos;
 927                                 prevResult->oid = HeapTupleGetOid(opctup);
 928                                 prevResult->opcintype = opcform->opcintype;
 929                                 prevResult->opcdefault = opcform->opcdefault;
 930                                 prevResult->opckeytype = opcform->opckeytype;
 931                                 continue;
 932                         }
 933                 }
 934
 935                 /*
 936                  * Okay to add it to result list
 937                  */
 938                 newResult = (OpclassCandidateList)
 939                         palloc(sizeof(struct _OpclassCandidateList));
 940                 newResult->opcname_tmp = NameStr(opcform->opcname);
 941                 newResult->pathpos = pathpos;
 942                 newResult->oid = HeapTupleGetOid(opctup);
 943                 newResult->opcintype = opcform->opcintype;
 944                 newResult->opcdefault = opcform->opcdefault;
 945                 newResult->opckeytype = opcform->opckeytype;
 946                 newResult->next = resultList;
 947                 resultList = newResult;
 948         }
 949
 950         ReleaseSysCacheList(catlist);
 951
 952         return resultList;
 953 }
 954
 955 /*
 956  * OpclassnameGetOpcid
 957  *              Try to resolve an unqualified index opclass name.
 958  *              Returns OID if opclass found in search path, else InvalidOid.
 959  *
 960  * This is essentially the same as TypenameGetTypid, but we have to have
 961  * an extra argument for the index AM OID.
 962  */
 963 Oid
 964 OpclassnameGetOpcid(Oid amid, const char *opcname)
 965 {
 966         Oid                     opcid;
 967         List       *lptr;
 968
 969         recomputeNamespacePath();
 970
 971         foreach(lptr, namespaceSearchPath)
 972         {
 973                 Oid                     namespaceId = (Oid) lfirsti(lptr);
 974
 975                 opcid = GetSysCacheOid(CLAAMNAMENSP,
 976                                                            ObjectIdGetDatum(amid),
 977                                                            PointerGetDatum(opcname),
 978                                                            ObjectIdGetDatum(namespaceId),
 979                                                            0);
 980                 if (OidIsValid(opcid))
 981                         return opcid;
 982         }
 983
 984         /* Not found in path */
 985         return InvalidOid;
 986 }
 987
 988 /*
 989  * OpclassIsVisible
 990  *              Determine whether an opclass (identified by OID) is visible in the
 991  *              current search path.  Visible means "would be found by searching
 992  *              for the unqualified opclass name".
 993  */
 994 bool
 995 OpclassIsVisible(Oid opcid)
 996 {
 997         HeapTuple       opctup;
 998         Form_pg_opclass opcform;
 999         Oid                     opcnamespace;
1000         bool            visible;
1001
1002         opctup = SearchSysCache(CLAOID,
1003                                                         ObjectIdGetDatum(opcid),
1004                                                         0, 0, 0);
1005         if (!HeapTupleIsValid(opctup))
1006                 elog(ERROR, "Cache lookup failed for opclass %u", opcid);
1007         opcform = (Form_pg_opclass) GETSTRUCT(opctup);
1008
1009         recomputeNamespacePath();
1010
1011         /*
1012          * Quick check: if it ain't in the path at all, it ain't visible.
1013          * Items in the system namespace are surely in the path and so we
1014          * needn't even do intMember() for them.
1015          */
1016         opcnamespace = opcform->opcnamespace;
1017         if (opcnamespace != PG_CATALOG_NAMESPACE &&
1018                 !intMember(opcnamespace, namespaceSearchPath))
1019                 visible = false;
1020         else
1021         {
1022                 /*
1023                  * If it is in the path, it might still not be visible; it could
1024                  * be hidden by another opclass of the same name earlier in the
1025                  * path. So we must do a slow check to see if this opclass would
1026                  * be found by OpclassnameGetOpcid.
1027                  */
1028                 char       *opcname = NameStr(opcform->opcname);
1029
1030                 visible = (OpclassnameGetOpcid(opcform->opcamid, opcname) == opcid);
1031         }
1032
1033         ReleaseSysCache(opctup);
1034
1035         return visible;
1036 }
1037
1038 /*
1039  * DeconstructQualifiedName
1040  *              Given a possibly-qualified name expressed as a list of String nodes,
1041  *              extract the schema name and object name.
1042  *
1043  * *nspname_p is set to NULL if there is no explicit schema name.
1044  */
1045 void
1046 DeconstructQualifiedName(List *names,
1047                                                  char **nspname_p,
1048                                                  char **objname_p)
1049 {
1050         char       *catalogname;
1051         char       *schemaname = NULL;
1052         char       *objname = NULL;
1053
1054         switch (length(names))
1055         {
1056                 case 1:
1057                         objname = strVal(lfirst(names));
1058                         break;
1059                 case 2:
1060                         schemaname = strVal(lfirst(names));
1061                         objname = strVal(lsecond(names));
1062                         break;
1063                 case 3:
1064                         catalogname = strVal(lfirst(names));
1065                         schemaname = strVal(lsecond(names));
1066                         objname = strVal(lfirst(lnext(lnext(names))));
1067
1068                         /*
1069                          * We check the catalog name and then ignore it.
1070                          */
1071                         if (strcmp(catalogname, DatabaseName) != 0)
1072                                 elog(ERROR, "Cross-database references are not implemented");
1073                         break;
1074                 default:
1075                         elog(ERROR, "Improper qualified name (too many dotted names): %s",
1076                                  NameListToString(names));
1077                         break;
1078         }
1079
1080         *nspname_p = schemaname;
1081         *objname_p = objname;
1082 }
1083
1084 /*
1085  * LookupExplicitNamespace
1086  *              Process an explicitly-specified schema name: look up the schema
1087  *              and verify we have USAGE (lookup) rights in it.
1088  *
1089  * Returns the namespace OID.  Raises elog if any problem.
1090  */
1091 Oid
1092 LookupExplicitNamespace(const char *nspname)
1093 {
1094         Oid                     namespaceId;
1095         AclResult       aclresult;
1096
1097         namespaceId = GetSysCacheOid(NAMESPACENAME,
1098                                                                  CStringGetDatum(nspname),
1099                                                                  0, 0, 0);
1100         if (!OidIsValid(namespaceId))
1101                 elog(ERROR, "Namespace \"%s\" does not exist", nspname);
1102
1103         aclresult = pg_namespace_aclcheck(namespaceId, GetUserId(), ACL_USAGE);
1104         if (aclresult != ACLCHECK_OK)
1105                 aclcheck_error(aclresult, nspname);
1106
1107         return namespaceId;
1108 }
1109
1110 /*
1111  * QualifiedNameGetCreationNamespace
1112  *              Given a possibly-qualified name for an object (in List-of-Values
1113  *              format), determine what namespace the object should be created in.
1114  *              Also extract and return the object name (last component of list).
1115  *
1116  * This is *not* used for tables.  Hence, the TEMP table namespace is
1117  * never selected as the creation target.
1118  */
1119 Oid
1120 QualifiedNameGetCreationNamespace(List *names, char **objname_p)
1121 {
1122         char       *schemaname;
1123         char       *objname;
1124         Oid                     namespaceId;
1125
1126         /* deconstruct the name list */
1127         DeconstructQualifiedName(names, &schemaname, &objname);
1128
1129         if (schemaname)
1130         {
1131                 /* use exact schema given */
1132                 namespaceId = GetSysCacheOid(NAMESPACENAME,
1133                                                                          CStringGetDatum(schemaname),
1134                                                                          0, 0, 0);
1135                 if (!OidIsValid(namespaceId))
1136                         elog(ERROR, "Namespace \"%s\" does not exist",
1137                                  schemaname);
1138                 /* we do not check for USAGE rights here! */
1139         }
1140         else
1141         {
1142                 /* use the default creation namespace */
1143                 recomputeNamespacePath();
1144                 namespaceId = defaultCreationNamespace;
1145                 if (!OidIsValid(namespaceId))
1146                         elog(ERROR, "No namespace has been selected to create in");
1147         }
1148
1149         /* Note: callers will check for CREATE rights when appropriate */
1150
1151         *objname_p = objname;
1152         return namespaceId;
1153 }
1154
1155 /*
1156  * makeRangeVarFromNameList
1157  *              Utility routine to convert a qualified-name list into RangeVar form.
1158  */
1159 RangeVar *
1160 makeRangeVarFromNameList(List *names)
1161 {
1162         RangeVar   *rel = makeRangeVar(NULL, NULL);
1163
1164         switch (length(names))
1165         {
1166                 case 1:
1167                         rel->relname = strVal(lfirst(names));
1168                         break;
1169                 case 2:
1170                         rel->schemaname = strVal(lfirst(names));
1171                         rel->relname = strVal(lsecond(names));
1172                         break;
1173                 case 3:
1174                         rel->catalogname = strVal(lfirst(names));
1175                         rel->schemaname = strVal(lsecond(names));
1176                         rel->relname = strVal(lfirst(lnext(lnext(names))));
1177                         break;
1178                 default:
1179                         elog(ERROR, "Improper relation name (too many dotted names)");
1180                         break;
1181         }
1182
1183         return rel;
1184 }
1185
1186 /*
1187  * NameListToString
1188  *              Utility routine to convert a qualified-name list into a string.
1189  *
1190  * This is used primarily to form error messages, and so we do not quote
1191  * the list elements, for the sake of legibility.
1192  */
1193 char *
1194 NameListToString(List *names)
1195 {
1196         StringInfoData string;
1197         List       *l;
1198
1199         initStringInfo(&string);
1200
1201         foreach(l, names)
1202         {
1203                 if (l != names)
1204                         appendStringInfoChar(&string, '.');
1205                 appendStringInfo(&string, "%s", strVal(lfirst(l)));
1206         }
1207
1208         return string.data;
1209 }
1210
1211 /*
1212  * NameListToQuotedString
1213  *              Utility routine to convert a qualified-name list into a string.
1214  *
1215  * Same as above except that names will be double-quoted where necessary,
1216  * so the string could be re-parsed (eg, by textToQualifiedNameList).
1217  */
1218 char *
1219 NameListToQuotedString(List *names)
1220 {
1221         StringInfoData string;
1222         List       *l;
1223
1224         initStringInfo(&string);
1225
1226         foreach(l, names)
1227         {
1228                 if (l != names)
1229                         appendStringInfoChar(&string, '.');
1230                 appendStringInfo(&string, "%s", quote_identifier(strVal(lfirst(l))));
1231         }
1232
1233         return string.data;
1234 }
1235
1236 /*
1237  * isTempNamespace - is the given namespace my temporary-table namespace?
1238  */
1239 bool
1240 isTempNamespace(Oid namespaceId)
1241 {
1242         if (OidIsValid(myTempNamespace) && myTempNamespace == namespaceId)
1243                 return true;
1244         return false;
1245 }
1246
1247 /*
1248  * isOtherTempNamespace - is the given namespace some other backend's
1249  * temporary-table namespace?
1250  */
1251 bool
1252 isOtherTempNamespace(Oid namespaceId)
1253 {
1254         bool            result;
1255         char       *nspname;
1256
1257         /* If it's my own temp namespace, say "false" */
1258         if (isTempNamespace(namespaceId))
1259                 return false;
1260         /* Else, if the namespace name starts with "pg_temp_", say "true" */
1261         nspname = get_namespace_name(namespaceId);
1262         if (!nspname)
1263                 return false;                   /* no such namespace? */
1264         result = (strncmp(nspname, "pg_temp_", 8) == 0);
1265         pfree(nspname);
1266         return result;
1267 }
1268
1269 /*
1270  * PushSpecialNamespace - push a "special" namespace onto the front of the
1271  * search path.
1272  *
1273  * This is a slightly messy hack intended only for support of CREATE SCHEMA.
1274  * Although the API is defined to allow a stack of pushed namespaces, we
1275  * presently only support one at a time.
1276  *
1277  * The pushed namespace will be removed from the search path at end of
1278  * transaction, whether commit or abort.
1279  */
1280 void
1281 PushSpecialNamespace(Oid namespaceId)
1282 {
1283         Assert(!OidIsValid(mySpecialNamespace));
1284         mySpecialNamespace = namespaceId;
1285         namespaceSearchPathValid = false;
1286 }
1287
1288 /*
1289  * PopSpecialNamespace - remove previously pushed special namespace.
1290  */
1291 void
1292 PopSpecialNamespace(Oid namespaceId)
1293 {
1294         Assert(mySpecialNamespace == namespaceId);
1295         mySpecialNamespace = InvalidOid;
1296         namespaceSearchPathValid = false;
1297 }
1298
1299 /*
1300  * FindConversionByName - find a conversion by possibly qualified name
1301  */
1302 Oid
1303 FindConversionByName(List *name)
1304 {
1305         char       *schemaname;
1306         char       *conversion_name;
1307         Oid                     namespaceId;
1308         Oid                     conoid;
1309         List       *lptr;
1310
1311         /* deconstruct the name list */
1312         DeconstructQualifiedName(name, &schemaname, &conversion_name);
1313
1314         if (schemaname)
1315         {
1316                 /* use exact schema given */
1317                 namespaceId = LookupExplicitNamespace(schemaname);
1318                 return FindConversion(conversion_name, namespaceId);
1319         }
1320         else
1321         {
1322                 /* search for it in search path */
1323                 recomputeNamespacePath();
1324
1325                 foreach(lptr, namespaceSearchPath)
1326                 {
1327                         namespaceId = (Oid) lfirsti(lptr);
1328                         conoid = FindConversion(conversion_name, namespaceId);
1329                         if (OidIsValid(conoid))
1330                                 return conoid;
1331                 }
1332         }
1333
1334         /* Not found in path */
1335         return InvalidOid;
1336 }
1337
1338 /*
1339  * FindDefaultConversionProc - find default encoding conversion proc
1340  */
1341 Oid
1342 FindDefaultConversionProc(int4 for_encoding, int4 to_encoding)
1343 {
1344         Oid                     proc;
1345         List       *lptr;
1346
1347         recomputeNamespacePath();
1348
1349         foreach(lptr, namespaceSearchPath)
1350         {
1351                 Oid                     namespaceId = (Oid) lfirsti(lptr);
1352
1353                 proc = FindDefaultConversion(namespaceId, for_encoding, to_encoding);
1354                 if (OidIsValid(proc))
1355                         return proc;
1356         }
1357
1358         /* Not found in path */
1359         return InvalidOid;
1360 }
1361
1362 /*
1363  * recomputeNamespacePath - recompute path derived variables if needed.
1364  */
1365 static void
1366 recomputeNamespacePath(void)
1367 {
1368         AclId           userId = GetUserId();
1369         char       *rawname;
1370         List       *namelist;
1371         List       *oidlist;
1372         List       *newpath;
1373         List       *l;
1374         Oid                     firstNS;
1375         MemoryContext oldcxt;
1376
1377         /*
1378          * Do nothing if path is already valid.
1379          */
1380         if (namespaceSearchPathValid && namespaceUser == userId)
1381                 return;
1382
1383         /* Need a modifiable copy of namespace_search_path string */
1384         rawname = pstrdup(namespace_search_path);
1385
1386         /* Parse string into list of identifiers */
1387         if (!SplitIdentifierString(rawname, ',', &namelist))
1388         {
1389                 /* syntax error in name list */
1390                 /* this should not happen if GUC checked check_search_path */
1391                 elog(ERROR, "recomputeNamespacePath: invalid list syntax");
1392         }
1393
1394         /*
1395          * Convert the list of names to a list of OIDs.  If any names are not
1396          * recognizable or we don't have read access, just leave them out of
1397          * the list.  (We can't raise an error, since the search_path setting
1398          * has already been accepted.)  Don't make duplicate entries, either.
1399          */
1400         oidlist = NIL;
1401         foreach(l, namelist)
1402         {
1403                 char       *curname = (char *) lfirst(l);
1404                 Oid                     namespaceId;
1405
1406                 if (strcmp(curname, "$user") == 0)
1407                 {
1408                         /* $user --- substitute namespace matching user name, if any */
1409                         HeapTuple       tuple;
1410
1411                         tuple = SearchSysCache(SHADOWSYSID,
1412                                                                    ObjectIdGetDatum(userId),
1413                                                                    0, 0, 0);
1414                         if (HeapTupleIsValid(tuple))
1415                         {
1416                                 char       *uname;
1417
1418                                 uname = NameStr(((Form_pg_shadow) GETSTRUCT(tuple))->usename);
1419                                 namespaceId = GetSysCacheOid(NAMESPACENAME,
1420                                                                                          CStringGetDatum(uname),
1421                                                                                          0, 0, 0);
1422                                 ReleaseSysCache(tuple);
1423                                 if (OidIsValid(namespaceId) &&
1424                                         !intMember(namespaceId, oidlist) &&
1425                                         pg_namespace_aclcheck(namespaceId, userId,
1426                                                                                   ACL_USAGE) == ACLCHECK_OK)
1427                                         oidlist = lappendi(oidlist, namespaceId);
1428                         }
1429                 }
1430                 else
1431                 {
1432                         /* normal namespace reference */
1433                         namespaceId = GetSysCacheOid(NAMESPACENAME,
1434                                                                                  CStringGetDatum(curname),
1435                                                                                  0, 0, 0);
1436                         if (OidIsValid(namespaceId) &&
1437                                 !intMember(namespaceId, oidlist) &&
1438                                 pg_namespace_aclcheck(namespaceId, userId,
1439                                                                           ACL_USAGE) == ACLCHECK_OK)
1440                                 oidlist = lappendi(oidlist, namespaceId);
1441                 }
1442         }
1443
1444         /*
1445          * Remember the first member of the explicit list.
1446          */
1447         if (oidlist == NIL)
1448                 firstNS = InvalidOid;
1449         else
1450                 firstNS = (Oid) lfirsti(oidlist);
1451
1452         /*
1453          * Add any implicitly-searched namespaces to the list.  Note these go
1454          * on the front, not the back; also notice that we do not check USAGE
1455          * permissions for these.
1456          */
1457         if (!intMember(PG_CATALOG_NAMESPACE, oidlist))
1458                 oidlist = lconsi(PG_CATALOG_NAMESPACE, oidlist);
1459
1460         if (OidIsValid(myTempNamespace) &&
1461                 !intMember(myTempNamespace, oidlist))
1462                 oidlist = lconsi(myTempNamespace, oidlist);
1463
1464         if (OidIsValid(mySpecialNamespace) &&
1465                 !intMember(mySpecialNamespace, oidlist))
1466                 oidlist = lconsi(mySpecialNamespace, oidlist);
1467
1468         /*
1469          * Now that we've successfully built the new list of namespace OIDs,
1470          * save it in permanent storage.
1471          */
1472         oldcxt = MemoryContextSwitchTo(TopMemoryContext);
1473         newpath = listCopy(oidlist);
1474         MemoryContextSwitchTo(oldcxt);
1475
1476         /* Now safe to assign to state variable. */
1477         freeList(namespaceSearchPath);
1478         namespaceSearchPath = newpath;
1479
1480         /*
1481          * Update info derived from search path.
1482          */
1483         firstExplicitNamespace = firstNS;
1484         if (OidIsValid(mySpecialNamespace))
1485                 defaultCreationNamespace = mySpecialNamespace;
1486         else
1487                 defaultCreationNamespace = firstNS;
1488
1489         /* Mark the path valid. */
1490         namespaceSearchPathValid = true;
1491         namespaceUser = userId;
1492
1493         /* Clean up. */
1494         pfree(rawname);
1495         freeList(namelist);
1496         freeList(oidlist);
1497 }
1498
1499 /*
1500  * InitTempTableNamespace
1501  *              Initialize temp table namespace on first use in a particular backend
1502  */
1503 static void
1504 InitTempTableNamespace(void)
1505 {
1506         char            namespaceName[NAMEDATALEN];
1507         Oid                     namespaceId;
1508
1509         /*
1510          * First, do permission check to see if we are authorized to make temp
1511          * tables.      We use a nonstandard error message here since
1512          * "databasename: permission denied" might be a tad cryptic.
1513          *
1514          * Note we apply the check to the session user, not the currently active
1515          * userid, since we are not going to change our minds about temp table
1516          * availability during the session.
1517          */
1518         if (pg_database_aclcheck(MyDatabaseId, GetSessionUserId(),
1519                                                          ACL_CREATE_TEMP) != ACLCHECK_OK)
1520                 elog(ERROR, "%s: not authorized to create temp tables",
1521                          DatabaseName);
1522
1523         snprintf(namespaceName, NAMEDATALEN, "pg_temp_%d", MyBackendId);
1524
1525         namespaceId = GetSysCacheOid(NAMESPACENAME,
1526                                                                  CStringGetDatum(namespaceName),
1527                                                                  0, 0, 0);
1528         if (!OidIsValid(namespaceId))
1529         {
1530                 /*
1531                  * First use of this temp namespace in this database; create it.
1532                  * The temp namespaces are always owned by the superuser.  We
1533                  * leave their permissions at default --- i.e., no access except
1534                  * to superuser --- to ensure that unprivileged users can't peek
1535                  * at other backends' temp tables.  This works because the places
1536                  * that access the temp namespace for my own backend skip
1537                  * permissions checks on it.
1538                  */
1539                 namespaceId = NamespaceCreate(namespaceName, BOOTSTRAP_USESYSID);
1540                 /* Advance command counter to make namespace visible */
1541                 CommandCounterIncrement();
1542         }
1543         else
1544         {
1545                 /*
1546                  * If the namespace already exists, clean it out (in case the
1547                  * former owner crashed without doing so).
1548                  */
1549                 RemoveTempRelations(namespaceId);
1550         }
1551
1552         /*
1553          * Okay, we've prepared the temp namespace ... but it's not committed
1554          * yet, so all our work could be undone by transaction rollback.  Set
1555          * flag for AtEOXact_Namespace to know what to do.
1556          */
1557         myTempNamespace = namespaceId;
1558
1559         firstTempTransaction = true;
1560
1561         namespaceSearchPathValid = false;       /* need to rebuild list */
1562 }
1563
1564 /*
1565  * End-of-transaction cleanup for namespaces.
1566  */
1567 void
1568 AtEOXact_Namespace(bool isCommit)
1569 {
1570         /*
1571          * If we abort the transaction in which a temp namespace was selected,
1572          * we'll have to do any creation or cleanout work over again.  So,
1573          * just forget the namespace entirely until next time.  On the other
1574          * hand, if we commit then register an exit callback to clean out the
1575          * temp tables at backend shutdown.  (We only want to register the
1576          * callback once per session, so this is a good place to do it.)
1577          */
1578         if (firstTempTransaction)
1579         {
1580                 if (isCommit)
1581                         on_shmem_exit(RemoveTempRelationsCallback, 0);
1582                 else
1583                 {
1584                         myTempNamespace = InvalidOid;
1585                         namespaceSearchPathValid = false;       /* need to rebuild list */
1586                 }
1587                 firstTempTransaction = false;
1588         }
1589
1590         /*
1591          * Clean up if someone failed to do PopSpecialNamespace
1592          */
1593         if (OidIsValid(mySpecialNamespace))
1594         {
1595                 mySpecialNamespace = InvalidOid;
1596                 namespaceSearchPathValid = false;               /* need to rebuild list */
1597         }
1598 }
1599
1600 /*
1601  * Remove all relations in the specified temp namespace.
1602  *
1603  * This is called at backend shutdown (if we made any temp relations).
1604  * It is also called when we begin using a pre-existing temp namespace,
1605  * in order to clean out any relations that might have been created by
1606  * a crashed backend.
1607  */
1608 static void
1609 RemoveTempRelations(Oid tempNamespaceId)
1610 {
1611         Relation        pgclass;
1612         HeapScanDesc scan;
1613         HeapTuple       tuple;
1614         ScanKeyData key;
1615         ObjectAddress object;
1616
1617         /*
1618          * Scan pg_class to find all the relations in the target namespace.
1619          * Ignore indexes, though, on the assumption that they'll go away when
1620          * their tables are deleted.
1621          *
1622          * NOTE: if there are deletion constraints between temp relations, then
1623          * our CASCADE delete call may cause as-yet-unvisited objects to go
1624          * away.  This is okay because we are using SnapshotNow; when the scan
1625          * does reach those pg_class tuples, they'll be ignored as already
1626          * deleted.
1627          */
1628         ScanKeyEntryInitialize(&key, 0x0,
1629                                                    Anum_pg_class_relnamespace,
1630                                                    F_OIDEQ,
1631                                                    ObjectIdGetDatum(tempNamespaceId));
1632
1633         pgclass = heap_openr(RelationRelationName, AccessShareLock);
1634         scan = heap_beginscan(pgclass, SnapshotNow, 1, &key);
1635
1636         while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
1637         {
1638                 switch (((Form_pg_class) GETSTRUCT(tuple))->relkind)
1639                 {
1640                         case RELKIND_RELATION:
1641                         case RELKIND_SEQUENCE:
1642                         case RELKIND_VIEW:
1643                                 object.classId = RelOid_pg_class;
1644                                 object.objectId = HeapTupleGetOid(tuple);
1645                                 object.objectSubId = 0;
1646                                 performDeletion(&object, DROP_CASCADE);
1647                                 break;
1648                         default:
1649                                 break;
1650                 }
1651         }
1652
1653         heap_endscan(scan);
1654         heap_close(pgclass, AccessShareLock);
1655 }
1656
1657 /*
1658  * Callback to remove temp relations at backend exit.
1659  */
1660 static void
1661 RemoveTempRelationsCallback(void)
1662 {
1663         if (OidIsValid(myTempNamespace))        /* should always be true */
1664         {
1665                 /* Need to ensure we have a usable transaction. */
1666                 AbortOutOfAnyTransaction();
1667                 StartTransactionCommand(true);
1668
1669                 RemoveTempRelations(myTempNamespace);
1670
1671                 CommitTransactionCommand(true);
1672         }
1673 }
1674
1675
1676 /*
1677  * Routines for handling the GUC variable 'search_path'.
1678  */
1679
1680 /* assign_hook: validate new search_path, do extra actions as needed */
1681 const char *
1682 assign_search_path(const char *newval, bool doit, bool interactive)
1683 {
1684         char       *rawname;
1685         List       *namelist;
1686         List       *l;
1687
1688         /* Need a modifiable copy of string */
1689         rawname = pstrdup(newval);
1690
1691         /* Parse string into list of identifiers */
1692         if (!SplitIdentifierString(rawname, ',', &namelist))
1693         {
1694                 /* syntax error in name list */
1695                 pfree(rawname);
1696                 freeList(namelist);
1697                 return NULL;
1698         }
1699
1700         /*
1701          * If we aren't inside a transaction, we cannot do database access so
1702          * cannot verify the individual names.  Must accept the list on faith.
1703          */
1704         if (interactive && IsTransactionState())
1705         {
1706                 /*
1707                  * Verify that all the names are either valid namespace names or
1708                  * "$user".  We do not require $user to correspond to a valid
1709                  * namespace.  We do not check for USAGE rights, either; should
1710                  * we?
1711                  */
1712                 foreach(l, namelist)
1713                 {
1714                         char       *curname = (char *) lfirst(l);
1715
1716                         if (strcmp(curname, "$user") == 0)
1717                                 continue;
1718                         if (!SearchSysCacheExists(NAMESPACENAME,
1719                                                                           CStringGetDatum(curname),
1720                                                                           0, 0, 0))
1721                                 elog(ERROR, "Namespace \"%s\" does not exist", curname);
1722                 }
1723         }
1724
1725         pfree(rawname);
1726         freeList(namelist);
1727
1728         /*
1729          * We mark the path as needing recomputation, but don't do anything
1730          * until it's needed.  This avoids trying to do database access during
1731          * GUC initialization.
1732          */
1733         if (doit)
1734                 namespaceSearchPathValid = false;
1735
1736         return newval;
1737 }
1738
1739 /*
1740  * InitializeSearchPath: initialize module during InitPostgres.
1741  *
1742  * This is called after we are up enough to be able to do catalog lookups.
1743  */
1744 void
1745 InitializeSearchPath(void)
1746 {
1747         if (IsBootstrapProcessingMode())
1748         {
1749                 /*
1750                  * In bootstrap mode, the search path must be 'pg_catalog' so that
1751                  * tables are created in the proper namespace; ignore the GUC
1752                  * setting.
1753                  */
1754                 MemoryContext oldcxt;
1755
1756                 oldcxt = MemoryContextSwitchTo(TopMemoryContext);
1757                 namespaceSearchPath = makeListi1(PG_CATALOG_NAMESPACE);
1758                 MemoryContextSwitchTo(oldcxt);
1759                 defaultCreationNamespace = PG_CATALOG_NAMESPACE;
1760                 firstExplicitNamespace = PG_CATALOG_NAMESPACE;
1761                 namespaceSearchPathValid = true;
1762                 namespaceUser = GetUserId();
1763         }
1764         else
1765         {
1766                 /*
1767                  * In normal mode, arrange for a callback on any syscache
1768                  * invalidation of pg_namespace rows.
1769                  */
1770                 CacheRegisterSyscacheCallback(NAMESPACEOID,
1771                                                                           NamespaceCallback,
1772                                                                           (Datum) 0);
1773                 /* Force search path to be recomputed on next use */
1774                 namespaceSearchPathValid = false;
1775         }
1776 }
1777
1778 /*
1779  * NamespaceCallback
1780  *              Syscache inval callback function
1781  */
1782 static void
1783 NamespaceCallback(Datum arg, Oid relid)
1784 {
1785         /* Force search path to be recomputed on next use */
1786         namespaceSearchPathValid = false;
1787 }
1788
1789 /*
1790  * Fetch the active search path, expressed as a List of OIDs.
1791  *
1792  * The returned list includes the implicitly-prepended namespaces only if
1793  * includeImplicit is true.
1794  *
1795  * NB: caller must treat the list as read-only!
1796  */
1797 List *
1798 fetch_search_path(bool includeImplicit)
1799 {
1800         List       *result;
1801
1802         recomputeNamespacePath();
1803
1804         result = namespaceSearchPath;
1805         if (!includeImplicit)
1806         {
1807                 while (result && (Oid) lfirsti(result) != firstExplicitNamespace)
1808                         result = lnext(result);
1809         }
1810
1811         return result;
1812 }
1813
1814 /*
1815  * Export the FooIsVisible functions as SQL-callable functions.
1816  */
1817
1818 Datum
1819 pg_table_is_visible(PG_FUNCTION_ARGS)
1820 {
1821         Oid                     oid = PG_GETARG_OID(0);
1822
1823         PG_RETURN_BOOL(RelationIsVisible(oid));
1824 }
1825
1826 Datum
1827 pg_type_is_visible(PG_FUNCTION_ARGS)
1828 {
1829         Oid                     oid = PG_GETARG_OID(0);
1830
1831         PG_RETURN_BOOL(TypeIsVisible(oid));
1832 }
1833
1834 Datum
1835 pg_function_is_visible(PG_FUNCTION_ARGS)
1836 {
1837         Oid                     oid = PG_GETARG_OID(0);
1838
1839         PG_RETURN_BOOL(FunctionIsVisible(oid));
1840 }
1841
1842 Datum
1843 pg_operator_is_visible(PG_FUNCTION_ARGS)
1844 {
1845         Oid                     oid = PG_GETARG_OID(0);
1846
1847         PG_RETURN_BOOL(OperatorIsVisible(oid));
1848 }
1849
1850 Datum
1851 pg_opclass_is_visible(PG_FUNCTION_ARGS)
1852 {
1853         Oid                     oid = PG_GETARG_OID(0);
1854
1855         PG_RETURN_BOOL(OpclassIsVisible(oid));
1856 }