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