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-2005, 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.76 2005/06/28 05:08:52 tgl Exp $
  17  *
  18  *-------------------------------------------------------------------------
  19  */
  20 #include "postgres.h"
  21
  22 #include "access/xact.h"
  23 #include "catalog/dependency.h"
  24 #include "catalog/namespace.h"
  25 #include "catalog/pg_authid.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_type.h"
  32 #include "commands/dbcommands.h"
  33 #include "lib/stringinfo.h"
  34 #include "miscadmin.h"
  35 #include "nodes/makefuncs.h"
  36 #include "storage/backendid.h"
  37 #include "storage/ipc.h"
  38 #include "utils/acl.h"
  39 #include "utils/builtins.h"
  40 #include "utils/catcache.h"
  41 #include "utils/guc.h"
  42 #include "utils/inval.h"
  43 #include "utils/lsyscache.h"
  44 #include "utils/memutils.h"
  45 #include "utils/syscache.h"
  46
  47
  48 /*
  49  * The namespace search path is a possibly-empty list of namespace OIDs.
  50  * In addition to the explicit list, several implicitly-searched namespaces
  51  * may be included:
  52  *
  53  * 1. If a "special" namespace has been set by PushSpecialNamespace, it is
  54  * always searched first.  (This is a hack for CREATE SCHEMA.)
  55  *
  56  * 2. If a TEMP table namespace has been initialized in this session, it
  57  * is always searched just after any special namespace.
  58  *
  59  * 3. The system catalog namespace is always searched.  If the system
  60  * namespace is present in the explicit path then it will be searched in
  61  * the specified order; otherwise it will be searched after TEMP tables and
  62  * *before* the explicit list.  (It might seem that the system namespace
  63  * should be implicitly last, but this behavior appears to be required by
  64  * SQL99.  Also, this provides a way to search the system namespace first
  65  * without thereby making it the default creation target namespace.)
  66  *
  67  * The default creation target namespace is normally equal to the first
  68  * element of the explicit list, but is the "special" namespace when one
  69  * has been set.  If the explicit list is empty and there is no special
  70  * namespace, there is no default target.
  71  *
  72  * In bootstrap mode, the search path is set equal to 'pg_catalog', so that
  73  * the system namespace is the only one searched or inserted into.
  74  * The initdb script is also careful to set search_path to 'pg_catalog' for
  75  * its post-bootstrap standalone backend runs.  Otherwise the default search
  76  * path is determined by GUC.  The factory default path contains the PUBLIC
  77  * namespace (if it exists), preceded by the user's personal namespace
  78  * (if one exists).
  79  *
  80  * If namespaceSearchPathValid is false, then namespaceSearchPath (and other
  81  * derived variables) need to be recomputed from namespace_search_path.
  82  * We mark it invalid upon an assignment to namespace_search_path or receipt
  83  * of a syscache invalidation event for pg_namespace.  The recomputation
  84  * is done during the next lookup attempt.
  85  *
  86  * Any namespaces mentioned in namespace_search_path that are not readable
  87  * by the current user ID are simply left out of namespaceSearchPath; so
  88  * we have to be willing to recompute the path when current userid changes.
  89  * namespaceUser is the userid the path has been computed for.
  90  */
  91
  92 static List *namespaceSearchPath = NIL;
  93
  94 static Oid      namespaceUser = InvalidOid;
  95
  96 /* default place to create stuff; if InvalidOid, no default */
  97 static Oid      defaultCreationNamespace = InvalidOid;
  98
  99 /* first explicit member of list; usually same as defaultCreationNamespace */
 100 static Oid      firstExplicitNamespace = InvalidOid;
 101
 102 /* The above four values are valid only if namespaceSearchPathValid */
 103 static bool namespaceSearchPathValid = true;
 104
 105 /*
 106  * myTempNamespace is InvalidOid until and unless a TEMP namespace is set up
 107  * in a particular backend session (this happens when a CREATE TEMP TABLE
 108  * command is first executed).  Thereafter it's the OID of the temp namespace.
 109  *
 110  * myTempNamespaceSubID shows whether we've created the TEMP namespace in the
 111  * current subtransaction.  The flag propagates up the subtransaction tree,
 112  * so the main transaction will correctly recognize the flag if all
 113  * intermediate subtransactions commit.  When it is InvalidSubTransactionId,
 114  * we either haven't made the TEMP namespace yet, or have successfully
 115  * committed its creation, depending on whether myTempNamespace is valid.
 116  */
 117 static Oid      myTempNamespace = InvalidOid;
 118
 119 static SubTransactionId myTempNamespaceSubID = InvalidSubTransactionId;
 120
 121 /*
 122  * "Special" namespace for CREATE SCHEMA.  If set, it's the first search
 123  * path element, and also the default creation namespace.
 124  */
 125 static Oid      mySpecialNamespace = InvalidOid;
 126
 127 /*
 128  * This is the text equivalent of the search path --- it's the value
 129  * of the GUC variable 'search_path'.
 130  */
 131 char       *namespace_search_path = NULL;
 132
 133
 134 /* Local functions */
 135 static void recomputeNamespacePath(void);
 136 static void InitTempTableNamespace(void);
 137 static void RemoveTempRelations(Oid tempNamespaceId);
 138 static void RemoveTempRelationsCallback(int code, Datum arg);
 139 static void NamespaceCallback(Datum arg, Oid relid);
 140
 141 /* These don't really need to appear in any header file */
 142 Datum           pg_table_is_visible(PG_FUNCTION_ARGS);
 143 Datum           pg_type_is_visible(PG_FUNCTION_ARGS);
 144 Datum           pg_function_is_visible(PG_FUNCTION_ARGS);
 145 Datum           pg_operator_is_visible(PG_FUNCTION_ARGS);
 146 Datum           pg_opclass_is_visible(PG_FUNCTION_ARGS);
 147 Datum           pg_conversion_is_visible(PG_FUNCTION_ARGS);
 148
 149
 150 /*
 151  * RangeVarGetRelid
 152  *              Given a RangeVar describing an existing relation,
 153  *              select the proper namespace and look up the relation OID.
 154  *
 155  * If the relation is not found, return InvalidOid if failOK = true,
 156  * otherwise raise an error.
 157  */
 158 Oid
 159 RangeVarGetRelid(const RangeVar *relation, bool failOK)
 160 {
 161         Oid                     namespaceId;
 162         Oid                     relId;
 163
 164         /*
 165          * We check the catalog name and then ignore it.
 166          */
 167         if (relation->catalogname)
 168         {
 169                 if (strcmp(relation->catalogname, get_database_name(MyDatabaseId)) != 0)
 170                         ereport(ERROR,
 171                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 172                                          errmsg("cross-database references are not implemented: \"%s.%s.%s\"",
 173                                                         relation->catalogname, relation->schemaname,
 174                                                         relation->relname)));
 175         }
 176
 177         if (relation->schemaname)
 178         {
 179                 /* use exact schema given */
 180                 namespaceId = LookupExplicitNamespace(relation->schemaname);
 181                 relId = get_relname_relid(relation->relname, namespaceId);
 182         }
 183         else
 184         {
 185                 /* search the namespace path */
 186                 relId = RelnameGetRelid(relation->relname);
 187         }
 188
 189         if (!OidIsValid(relId) && !failOK)
 190         {
 191                 if (relation->schemaname)
 192                         ereport(ERROR,
 193                                         (errcode(ERRCODE_UNDEFINED_TABLE),
 194                                          errmsg("relation \"%s.%s\" does not exist",
 195                                                         relation->schemaname, relation->relname)));
 196                 else
 197                         ereport(ERROR,
 198                                         (errcode(ERRCODE_UNDEFINED_TABLE),
 199                                          errmsg("relation \"%s\" does not exist",
 200                                                         relation->relname)));
 201         }
 202         return relId;
 203 }
 204
 205 /*
 206  * RangeVarGetCreationNamespace
 207  *              Given a RangeVar describing a to-be-created relation,
 208  *              choose which namespace to create it in.
 209  *
 210  * Note: calling this may result in a CommandCounterIncrement operation.
 211  * That will happen on the first request for a temp table in any particular
 212  * backend run; we will need to either create or clean out the temp schema.
 213  */
 214 Oid
 215 RangeVarGetCreationNamespace(const RangeVar *newRelation)
 216 {
 217         Oid                     namespaceId;
 218
 219         /*
 220          * We check the catalog name and then ignore it.
 221          */
 222         if (newRelation->catalogname)
 223         {
 224                 if (strcmp(newRelation->catalogname, get_database_name(MyDatabaseId)) != 0)
 225                         ereport(ERROR,
 226                                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 227                                          errmsg("cross-database references are not implemented: \"%s.%s.%s\"",
 228                                            newRelation->catalogname, newRelation->schemaname,
 229                                                         newRelation->relname)));
 230         }
 231
 232         if (newRelation->istemp)
 233         {
 234                 /* TEMP tables are created in our backend-local temp namespace */
 235                 if (newRelation->schemaname)
 236                         ereport(ERROR,
 237                                         (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
 238                           errmsg("temporary tables may not specify a schema name")));
 239                 /* Initialize temp namespace if first time through */
 240                 if (!OidIsValid(myTempNamespace))
 241                         InitTempTableNamespace();
 242                 return myTempNamespace;
 243         }
 244
 245         if (newRelation->schemaname)
 246         {
 247                 /* use exact schema given */
 248                 namespaceId = GetSysCacheOid(NAMESPACENAME,
 249                                                                 CStringGetDatum(newRelation->schemaname),
 250                                                                          0, 0, 0);
 251                 if (!OidIsValid(namespaceId))
 252                         ereport(ERROR,
 253                                         (errcode(ERRCODE_UNDEFINED_SCHEMA),
 254                                          errmsg("schema \"%s\" does not exist",
 255                                                         newRelation->schemaname)));
 256                 /* we do not check for USAGE rights here! */
 257         }
 258         else
 259         {
 260                 /* use the default creation namespace */
 261                 recomputeNamespacePath();
 262                 namespaceId = defaultCreationNamespace;
 263                 if (!OidIsValid(namespaceId))
 264                         ereport(ERROR,
 265                                         (errcode(ERRCODE_UNDEFINED_SCHEMA),
 266                                          errmsg("no schema has been selected to create in")));
 267         }
 268
 269         /* Note: callers will check for CREATE rights when appropriate */
 270
 271         return namespaceId;
 272 }
 273
 274 /*
 275  * RelnameGetRelid
 276  *              Try to resolve an unqualified relation name.
 277  *              Returns OID if relation found in search path, else InvalidOid.
 278  */
 279 Oid
 280 RelnameGetRelid(const char *relname)
 281 {
 282         Oid                     relid;
 283         ListCell   *l;
 284
 285         recomputeNamespacePath();
 286
 287         foreach(l, namespaceSearchPath)
 288         {
 289                 Oid                     namespaceId = lfirst_oid(l);
 290
 291                 relid = get_relname_relid(relname, namespaceId);
 292                 if (OidIsValid(relid))
 293                         return relid;
 294         }
 295
 296         /* Not found in path */
 297         return InvalidOid;
 298 }
 299
 300
 301 /*
 302  * RelationIsVisible
 303  *              Determine whether a relation (identified by OID) is visible in the
 304  *              current search path.  Visible means "would be found by searching
 305  *              for the unqualified relation name".
 306  */
 307 bool
 308 RelationIsVisible(Oid relid)
 309 {
 310         HeapTuple       reltup;
 311         Form_pg_class relform;
 312         Oid                     relnamespace;
 313         bool            visible;
 314
 315         reltup = SearchSysCache(RELOID,
 316                                                         ObjectIdGetDatum(relid),
 317                                                         0, 0, 0);
 318         if (!HeapTupleIsValid(reltup))
 319                 elog(ERROR, "cache lookup failed for relation %u", relid);
 320         relform = (Form_pg_class) GETSTRUCT(reltup);
 321
 322         recomputeNamespacePath();
 323
 324         /*
 325          * Quick check: if it ain't in the path at all, it ain't visible.
 326          * Items in the system namespace are surely in the path and so we
 327          * needn't even do list_member_oid() for them.
 328          */
 329         relnamespace = relform->relnamespace;
 330         if (relnamespace != PG_CATALOG_NAMESPACE &&
 331                 !list_member_oid(namespaceSearchPath, relnamespace))
 332                 visible = false;
 333         else
 334         {
 335                 /*
 336                  * If it is in the path, it might still not be visible; it could
 337                  * be hidden by another relation of the same name earlier in the
 338                  * path. So we must do a slow check to see if this rel would be
 339                  * found by RelnameGetRelid.
 340                  */
 341                 char       *relname = NameStr(relform->relname);
 342
 343                 visible = (RelnameGetRelid(relname) == relid);
 344         }
 345
 346         ReleaseSysCache(reltup);
 347
 348         return visible;
 349 }
 350
 351
 352 /*
 353  * TypenameGetTypid
 354  *              Try to resolve an unqualified datatype name.
 355  *              Returns OID if type found in search path, else InvalidOid.
 356  *
 357  * This is essentially the same as RelnameGetRelid.
 358  */
 359 Oid
 360 TypenameGetTypid(const char *typname)
 361 {
 362         Oid                     typid;
 363         ListCell   *l;
 364
 365         recomputeNamespacePath();
 366
 367         foreach(l, namespaceSearchPath)
 368         {
 369                 Oid                     namespaceId = lfirst_oid(l);
 370
 371                 typid = GetSysCacheOid(TYPENAMENSP,
 372                                                            PointerGetDatum(typname),
 373                                                            ObjectIdGetDatum(namespaceId),
 374                                                            0, 0);
 375                 if (OidIsValid(typid))
 376                         return typid;
 377         }
 378
 379         /* Not found in path */
 380         return InvalidOid;
 381 }
 382
 383 /*
 384  * TypeIsVisible
 385  *              Determine whether a type (identified by OID) is visible in the
 386  *              current search path.  Visible means "would be found by searching
 387  *              for the unqualified type name".
 388  */
 389 bool
 390 TypeIsVisible(Oid typid)
 391 {
 392         HeapTuple       typtup;
 393         Form_pg_type typform;
 394         Oid                     typnamespace;
 395         bool            visible;
 396
 397         typtup = SearchSysCache(TYPEOID,
 398                                                         ObjectIdGetDatum(typid),
 399                                                         0, 0, 0);
 400         if (!HeapTupleIsValid(typtup))
 401                 elog(ERROR, "cache lookup failed for type %u", typid);
 402         typform = (Form_pg_type) GETSTRUCT(typtup);
 403
 404         recomputeNamespacePath();
 405
 406         /*
 407          * Quick check: if it ain't in the path at all, it ain't visible.
 408          * Items in the system namespace are surely in the path and so we
 409          * needn't even do list_member_oid() for them.
 410          */
 411         typnamespace = typform->typnamespace;
 412         if (typnamespace != PG_CATALOG_NAMESPACE &&
 413                 !list_member_oid(namespaceSearchPath, typnamespace))
 414                 visible = false;
 415         else
 416         {
 417                 /*
 418                  * If it is in the path, it might still not be visible; it could
 419                  * be hidden by another type of the same name earlier in the path.
 420                  * So we must do a slow check to see if this type would be found
 421                  * by TypenameGetTypid.
 422                  */
 423                 char       *typname = NameStr(typform->typname);
 424
 425                 visible = (TypenameGetTypid(typname) == typid);
 426         }
 427
 428         ReleaseSysCache(typtup);
 429
 430         return visible;
 431 }
 432
 433
 434 /*
 435  * FuncnameGetCandidates
 436  *              Given a possibly-qualified function name and argument count,
 437  *              retrieve a list of the possible matches.
 438  *
 439  * If nargs is -1, we return all functions matching the given name,
 440  * regardless of argument count.
 441  *
 442  * We search a single namespace if the function name is qualified, else
 443  * all namespaces in the search path.  The return list will never contain
 444  * multiple entries with identical argument lists --- in the multiple-
 445  * namespace case, we arrange for entries in earlier namespaces to mask
 446  * identical entries in later namespaces.
 447  */
 448 FuncCandidateList
 449 FuncnameGetCandidates(List *names, int nargs)
 450 {
 451         FuncCandidateList resultList = NULL;
 452         char       *schemaname;
 453         char       *funcname;
 454         Oid                     namespaceId;
 455         CatCList   *catlist;
 456         int                     i;
 457
 458         /* deconstruct the name list */
 459         DeconstructQualifiedName(names, &schemaname, &funcname);
 460
 461         if (schemaname)
 462         {
 463                 /* use exact schema given */
 464                 namespaceId = LookupExplicitNamespace(schemaname);
 465         }
 466         else
 467         {
 468                 /* flag to indicate we need namespace search */
 469                 namespaceId = InvalidOid;
 470                 recomputeNamespacePath();
 471         }
 472
 473         /* Search syscache by name only */
 474         catlist = SearchSysCacheList(PROCNAMEARGSNSP, 1,
 475                                                                  CStringGetDatum(funcname),
 476                                                                  0, 0, 0);
 477
 478         for (i = 0; i < catlist->n_members; i++)
 479         {
 480                 HeapTuple       proctup = &catlist->members[i]->tuple;
 481                 Form_pg_proc procform = (Form_pg_proc) GETSTRUCT(proctup);
 482                 int                     pronargs = procform->pronargs;
 483                 int                     pathpos = 0;
 484                 FuncCandidateList newResult;
 485
 486                 /* Ignore if it doesn't match requested argument count */
 487                 if (nargs >= 0 && pronargs != nargs)
 488                         continue;
 489
 490                 if (OidIsValid(namespaceId))
 491                 {
 492                         /* Consider only procs in specified namespace */
 493                         if (procform->pronamespace != namespaceId)
 494                                 continue;
 495                         /* No need to check args, they must all be different */
 496                 }
 497                 else
 498                 {
 499                         /* Consider only procs that are in the search path */
 500                         ListCell   *nsp;
 501
 502                         foreach(nsp, namespaceSearchPath)
 503                         {
 504                                 if (procform->pronamespace == lfirst_oid(nsp))
 505                                         break;
 506                                 pathpos++;
 507                         }
 508                         if (nsp == NULL)
 509                                 continue;               /* proc is not in search path */
 510
 511                         /*
 512                          * Okay, it's in the search path, but does it have the same
 513                          * arguments as something we already accepted?  If so, keep
 514                          * only the one that appears earlier in the search path.
 515                          *
 516                          * If we have an ordered list from SearchSysCacheList (the normal
 517                          * case), then any conflicting proc must immediately adjoin
 518                          * this one in the list, so we only need to look at the newest
 519                          * result item.  If we have an unordered list, we have to scan
 520                          * the whole result list.
 521                          */
 522                         if (resultList)
 523                         {
 524                                 FuncCandidateList prevResult;
 525
 526                                 if (catlist->ordered)
 527                                 {
 528                                         if (pronargs == resultList->nargs &&
 529                                                 memcmp(procform->proargtypes.values,
 530                                                            resultList->args,
 531                                                            pronargs * sizeof(Oid)) == 0)
 532                                                 prevResult = resultList;
 533                                         else
 534                                                 prevResult = NULL;
 535                                 }
 536                                 else
 537                                 {
 538                                         for (prevResult = resultList;
 539                                                  prevResult;
 540                                                  prevResult = prevResult->next)
 541                                         {
 542                                                 if (pronargs == prevResult->nargs &&
 543                                                   memcmp(procform->proargtypes.values,
 544                                                                  prevResult->args,
 545                                                                  pronargs * sizeof(Oid)) == 0)
 546                                                         break;
 547                                         }
 548                                 }
 549                                 if (prevResult)
 550                                 {
 551                                         /* We have a match with a previous result */
 552                                         Assert(pathpos != prevResult->pathpos);
 553                                         if (pathpos > prevResult->pathpos)
 554                                                 continue;               /* keep previous result */
 555                                         /* replace previous result */
 556                                         prevResult->pathpos = pathpos;
 557                                         prevResult->oid = HeapTupleGetOid(proctup);
 558                                         continue;       /* args are same, of course */
 559                                 }
 560                         }
 561                 }
 562
 563                 /*
 564                  * Okay to add it to result list
 565                  */
 566                 newResult = (FuncCandidateList)
 567                         palloc(sizeof(struct _FuncCandidateList) - sizeof(Oid)
 568                                    + pronargs * sizeof(Oid));
 569                 newResult->pathpos = pathpos;
 570                 newResult->oid = HeapTupleGetOid(proctup);
 571                 newResult->nargs = pronargs;
 572                 memcpy(newResult->args, procform->proargtypes.values,
 573                            pronargs * sizeof(Oid));
 574
 575                 newResult->next = resultList;
 576                 resultList = newResult;
 577         }
 578
 579         ReleaseSysCacheList(catlist);
 580
 581         return resultList;
 582 }
 583
 584 /*
 585  * FunctionIsVisible
 586  *              Determine whether a function (identified by OID) is visible in the
 587  *              current search path.  Visible means "would be found by searching
 588  *              for the unqualified function name with exact argument matches".
 589  */
 590 bool
 591 FunctionIsVisible(Oid funcid)
 592 {
 593         HeapTuple       proctup;
 594         Form_pg_proc procform;
 595         Oid                     pronamespace;
 596         bool            visible;
 597
 598         proctup = SearchSysCache(PROCOID,
 599                                                          ObjectIdGetDatum(funcid),
 600                                                          0, 0, 0);
 601         if (!HeapTupleIsValid(proctup))
 602                 elog(ERROR, "cache lookup failed for function %u", funcid);
 603         procform = (Form_pg_proc) GETSTRUCT(proctup);
 604
 605         recomputeNamespacePath();
 606
 607         /*
 608          * Quick check: if it ain't in the path at all, it ain't visible.
 609          * Items in the system namespace are surely in the path and so we
 610          * needn't even do list_member_oid() for them.
 611          */
 612         pronamespace = procform->pronamespace;
 613         if (pronamespace != PG_CATALOG_NAMESPACE &&
 614                 !list_member_oid(namespaceSearchPath, pronamespace))
 615                 visible = false;
 616         else
 617         {
 618                 /*
 619                  * If it is in the path, it might still not be visible; it could
 620                  * be hidden by another proc of the same name and arguments
 621                  * earlier in the path.  So we must do a slow check to see if this
 622                  * is the same proc that would be found by FuncnameGetCandidates.
 623                  */
 624                 char       *proname = NameStr(procform->proname);
 625                 int                     nargs = procform->pronargs;
 626                 FuncCandidateList clist;
 627
 628                 visible = false;
 629
 630                 clist = FuncnameGetCandidates(list_make1(makeString(proname)), nargs);
 631
 632                 for (; clist; clist = clist->next)
 633                 {
 634                         if (memcmp(clist->args, procform->proargtypes.values,
 635                                            nargs * sizeof(Oid)) == 0)
 636                         {
 637                                 /* Found the expected entry; is it the right proc? */
 638                                 visible = (clist->oid == funcid);
 639                                 break;
 640                         }
 641                 }
 642         }
 643
 644         ReleaseSysCache(proctup);
 645
 646         return visible;
 647 }
 648
 649
 650 /*
 651  * OpernameGetCandidates
 652  *              Given a possibly-qualified operator name and operator kind,
 653  *              retrieve a list of the possible matches.
 654  *
 655  * If oprkind is '\0', we return all operators matching the given name,
 656  * regardless of arguments.
 657  *
 658  * We search a single namespace if the operator name is qualified, else
 659  * all namespaces in the search path.  The return list will never contain
 660  * multiple entries with identical argument lists --- in the multiple-
 661  * namespace case, we arrange for entries in earlier namespaces to mask
 662  * identical entries in later namespaces.
 663  *
 664  * The returned items always have two args[] entries --- one or the other
 665  * will be InvalidOid for a prefix or postfix oprkind.  nargs is 2, too.
 666  */
 667 FuncCandidateList
 668 OpernameGetCandidates(List *names, char oprkind)
 669 {
 670         FuncCandidateList resultList = NULL;
 671         char       *resultSpace = NULL;
 672         int                     nextResult = 0;
 673         char       *schemaname;
 674         char       *opername;
 675         Oid                     namespaceId;
 676         CatCList   *catlist;
 677         int                     i;
 678
 679         /* deconstruct the name list */
 680         DeconstructQualifiedName(names, &schemaname, &opername);
 681
 682         if (schemaname)
 683         {
 684                 /* use exact schema given */
 685                 namespaceId = LookupExplicitNamespace(schemaname);
 686         }
 687         else
 688         {
 689                 /* flag to indicate we need namespace search */
 690                 namespaceId = InvalidOid;
 691                 recomputeNamespacePath();
 692         }
 693
 694         /* Search syscache by name only */
 695         catlist = SearchSysCacheList(OPERNAMENSP, 1,
 696                                                                  CStringGetDatum(opername),
 697                                                                  0, 0, 0);
 698
 699         /*
 700          * In typical scenarios, most if not all of the operators found by the
 701          * catcache search will end up getting returned; and there can be
 702          * quite a few, for common operator names such as '=' or '+'.  To
 703          * reduce the time spent in palloc, we allocate the result space as an
 704          * array large enough to hold all the operators.  The original coding
 705          * of this routine did a separate palloc for each operator, but
 706          * profiling revealed that the pallocs used an unreasonably large
 707          * 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         Oid             roleid = 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 == roleid)
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(AUTHOID,
1546                                                                    ObjectIdGetDatum(roleid),
1547                                                                    0, 0, 0);
1548                         if (HeapTupleIsValid(tuple))
1549                         {
1550                                 char       *rname;
1551
1552                                 rname = NameStr(((Form_pg_authid) GETSTRUCT(tuple))->rolname);
1553                                 namespaceId = GetSysCacheOid(NAMESPACENAME,
1554                                                                                          CStringGetDatum(rname),
1555                                                                                          0, 0, 0);
1556                                 ReleaseSysCache(tuple);
1557                                 if (OidIsValid(namespaceId) &&
1558                                         !list_member_oid(oidlist, namespaceId) &&
1559                                         pg_namespace_aclcheck(namespaceId, roleid,
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, roleid,
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 = roleid;
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
1649          * pg_namespace_aclmask; that's necessary since current user ID could
1650          * change during the session. But there's no need to make the
1651          * namespace in the first place until a temp table creation request is
1652          * made by someone with appropriate rights.
1653          */
1654         if (pg_database_aclcheck(MyDatabaseId, GetUserId(),
1655                                                          ACL_CREATE_TEMP) != ACLCHECK_OK)
1656                 ereport(ERROR,
1657                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1658                                  errmsg("permission denied to create temporary tables in database \"%s\"",
1659                                                 get_database_name(MyDatabaseId))));
1660
1661         snprintf(namespaceName, sizeof(namespaceName), "pg_temp_%d", MyBackendId);
1662
1663         namespaceId = GetSysCacheOid(NAMESPACENAME,
1664                                                                  CStringGetDatum(namespaceName),
1665                                                                  0, 0, 0);
1666         if (!OidIsValid(namespaceId))
1667         {
1668                 /*
1669                  * First use of this temp namespace in this database; create it.
1670                  * The temp namespaces are always owned by the superuser.  We
1671                  * leave their permissions at default --- i.e., no access except
1672                  * to superuser --- to ensure that unprivileged users can't peek
1673                  * at other backends' temp tables.  This works because the places
1674                  * that access the temp namespace for my own backend skip
1675                  * permissions checks on it.
1676                  */
1677                 namespaceId = NamespaceCreate(namespaceName, BOOTSTRAP_SUPERUSERID);
1678                 /* Advance command counter to make namespace visible */
1679                 CommandCounterIncrement();
1680         }
1681         else
1682         {
1683                 /*
1684                  * If the namespace already exists, clean it out (in case the
1685                  * former owner crashed without doing so).
1686                  */
1687                 RemoveTempRelations(namespaceId);
1688         }
1689
1690         /*
1691          * Okay, we've prepared the temp namespace ... but it's not committed
1692          * yet, so all our work could be undone by transaction rollback.  Set
1693          * flag for AtEOXact_Namespace to know what to do.
1694          */
1695         myTempNamespace = namespaceId;
1696
1697         /* It should not be done already. */
1698         AssertState(myTempNamespaceSubID == InvalidSubTransactionId);
1699         myTempNamespaceSubID = GetCurrentSubTransactionId();
1700
1701         namespaceSearchPathValid = false;       /* need to rebuild list */
1702 }
1703
1704 /*
1705  * End-of-transaction cleanup for namespaces.
1706  */
1707 void
1708 AtEOXact_Namespace(bool isCommit)
1709 {
1710         /*
1711          * If we abort the transaction in which a temp namespace was selected,
1712          * we'll have to do any creation or cleanout work over again.  So,
1713          * just forget the namespace entirely until next time.  On the other
1714          * hand, if we commit then register an exit callback to clean out the
1715          * temp tables at backend shutdown.  (We only want to register the
1716          * callback once per session, so this is a good place to do it.)
1717          */
1718         if (myTempNamespaceSubID != InvalidSubTransactionId)
1719         {
1720                 if (isCommit)
1721                         on_shmem_exit(RemoveTempRelationsCallback, 0);
1722                 else
1723                 {
1724                         myTempNamespace = InvalidOid;
1725                         namespaceSearchPathValid = false;       /* need to rebuild list */
1726                 }
1727                 myTempNamespaceSubID = InvalidSubTransactionId;
1728         }
1729
1730         /*
1731          * Clean up if someone failed to do PopSpecialNamespace
1732          */
1733         if (OidIsValid(mySpecialNamespace))
1734         {
1735                 mySpecialNamespace = InvalidOid;
1736                 namespaceSearchPathValid = false;               /* need to rebuild list */
1737         }
1738 }
1739
1740 /*
1741  * AtEOSubXact_Namespace
1742  *
1743  * At subtransaction commit, propagate the temp-namespace-creation
1744  * flag to the parent subtransaction.
1745  *
1746  * At subtransaction abort, forget the flag if we set it up.
1747  */
1748 void
1749 AtEOSubXact_Namespace(bool isCommit, SubTransactionId mySubid,
1750                                           SubTransactionId parentSubid)
1751 {
1752         if (myTempNamespaceSubID == mySubid)
1753         {
1754                 if (isCommit)
1755                         myTempNamespaceSubID = parentSubid;
1756                 else
1757                 {
1758                         myTempNamespaceSubID = InvalidSubTransactionId;
1759                         /* TEMP namespace creation failed, so reset state */
1760                         myTempNamespace = InvalidOid;
1761                         namespaceSearchPathValid = false;       /* need to rebuild list */
1762                 }
1763         }
1764 }
1765
1766 /*
1767  * Remove all relations in the specified temp namespace.
1768  *
1769  * This is called at backend shutdown (if we made any temp relations).
1770  * It is also called when we begin using a pre-existing temp namespace,
1771  * in order to clean out any relations that might have been created by
1772  * a crashed backend.
1773  */
1774 static void
1775 RemoveTempRelations(Oid tempNamespaceId)
1776 {
1777         ObjectAddress object;
1778
1779         /*
1780          * We want to get rid of everything in the target namespace, but not
1781          * the namespace itself (deleting it only to recreate it later would
1782          * be a waste of cycles).  We do this by finding everything that has a
1783          * dependency on the namespace.
1784          */
1785         object.classId = NamespaceRelationId;
1786         object.objectId = tempNamespaceId;
1787         object.objectSubId = 0;
1788
1789         deleteWhatDependsOn(&object, false);
1790 }
1791
1792 /*
1793  * Callback to remove temp relations at backend exit.
1794  */
1795 static void
1796 RemoveTempRelationsCallback(int code, Datum arg)
1797 {
1798         if (OidIsValid(myTempNamespace))        /* should always be true */
1799         {
1800                 /* Need to ensure we have a usable transaction. */
1801                 AbortOutOfAnyTransaction();
1802                 StartTransactionCommand();
1803
1804                 RemoveTempRelations(myTempNamespace);
1805
1806                 CommitTransactionCommand();
1807         }
1808 }
1809
1810
1811 /*
1812  * Routines for handling the GUC variable 'search_path'.
1813  */
1814
1815 /* assign_hook: validate new search_path, do extra actions as needed */
1816 const char *
1817 assign_search_path(const char *newval, bool doit, GucSource source)
1818 {
1819         char       *rawname;
1820         List       *namelist;
1821         ListCell   *l;
1822
1823         /* Need a modifiable copy of string */
1824         rawname = pstrdup(newval);
1825
1826         /* Parse string into list of identifiers */
1827         if (!SplitIdentifierString(rawname, ',', &namelist))
1828         {
1829                 /* syntax error in name list */
1830                 pfree(rawname);
1831                 list_free(namelist);
1832                 return NULL;
1833         }
1834
1835         /*
1836          * If we aren't inside a transaction, we cannot do database access so
1837          * cannot verify the individual names.  Must accept the list on faith.
1838          */
1839         if (source >= PGC_S_INTERACTIVE && IsTransactionState())
1840         {
1841                 /*
1842                  * Verify that all the names are either valid namespace names or
1843                  * "$user".  We do not require $user to correspond to a valid
1844                  * namespace.  We do not check for USAGE rights, either; should
1845                  * we?
1846                  *
1847                  * When source == PGC_S_TEST, we are checking the argument of an
1848                  * ALTER DATABASE SET or ALTER USER SET command.  It could be that
1849                  * the intended use of the search path is for some other database,
1850                  * so we should not error out if it mentions schemas not present
1851                  * in the current database.  We reduce the message to NOTICE
1852                  * instead.
1853                  */
1854                 foreach(l, namelist)
1855                 {
1856                         char       *curname = (char *) lfirst(l);
1857
1858                         if (strcmp(curname, "$user") == 0)
1859                                 continue;
1860                         if (!SearchSysCacheExists(NAMESPACENAME,
1861                                                                           CStringGetDatum(curname),
1862                                                                           0, 0, 0))
1863                                 ereport((source == PGC_S_TEST) ? NOTICE : ERROR,
1864                                                 (errcode(ERRCODE_UNDEFINED_SCHEMA),
1865                                            errmsg("schema \"%s\" does not exist", curname)));
1866                 }
1867         }
1868
1869         pfree(rawname);
1870         list_free(namelist);
1871
1872         /*
1873          * We mark the path as needing recomputation, but don't do anything
1874          * until it's needed.  This avoids trying to do database access during
1875          * GUC initialization.
1876          */
1877         if (doit)
1878                 namespaceSearchPathValid = false;
1879
1880         return newval;
1881 }
1882
1883 /*
1884  * InitializeSearchPath: initialize module during InitPostgres.
1885  *
1886  * This is called after we are up enough to be able to do catalog lookups.
1887  */
1888 void
1889 InitializeSearchPath(void)
1890 {
1891         if (IsBootstrapProcessingMode())
1892         {
1893                 /*
1894                  * In bootstrap mode, the search path must be 'pg_catalog' so that
1895                  * tables are created in the proper namespace; ignore the GUC
1896                  * setting.
1897                  */
1898                 MemoryContext oldcxt;
1899
1900                 oldcxt = MemoryContextSwitchTo(TopMemoryContext);
1901                 namespaceSearchPath = list_make1_oid(PG_CATALOG_NAMESPACE);
1902                 MemoryContextSwitchTo(oldcxt);
1903                 defaultCreationNamespace = PG_CATALOG_NAMESPACE;
1904                 firstExplicitNamespace = PG_CATALOG_NAMESPACE;
1905                 namespaceSearchPathValid = true;
1906                 namespaceUser = GetUserId();
1907         }
1908         else
1909         {
1910                 /*
1911                  * In normal mode, arrange for a callback on any syscache
1912                  * invalidation of pg_namespace rows.
1913                  */
1914                 CacheRegisterSyscacheCallback(NAMESPACEOID,
1915                                                                           NamespaceCallback,
1916                                                                           (Datum) 0);
1917                 /* Force search path to be recomputed on next use */
1918                 namespaceSearchPathValid = false;
1919         }
1920 }
1921
1922 /*
1923  * NamespaceCallback
1924  *              Syscache inval callback function
1925  */
1926 static void
1927 NamespaceCallback(Datum arg, Oid relid)
1928 {
1929         /* Force search path to be recomputed on next use */
1930         namespaceSearchPathValid = false;
1931 }
1932
1933 /*
1934  * Fetch the active search path. The return value is a palloc'ed list
1935  * of OIDs; the caller is responsible for freeing this storage as
1936  * appropriate.
1937  *
1938  * The returned list includes the implicitly-prepended namespaces only if
1939  * includeImplicit is true.
1940  */
1941 List *
1942 fetch_search_path(bool includeImplicit)
1943 {
1944         List       *result;
1945
1946         recomputeNamespacePath();
1947
1948         result = list_copy(namespaceSearchPath);
1949         if (!includeImplicit)
1950         {
1951                 while (result && linitial_oid(result) != firstExplicitNamespace)
1952                         result = list_delete_first(result);
1953         }
1954
1955         return result;
1956 }
1957
1958 /*
1959  * Export the FooIsVisible functions as SQL-callable functions.
1960  */
1961
1962 Datum
1963 pg_table_is_visible(PG_FUNCTION_ARGS)
1964 {
1965         Oid                     oid = PG_GETARG_OID(0);
1966
1967         PG_RETURN_BOOL(RelationIsVisible(oid));
1968 }
1969
1970 Datum
1971 pg_type_is_visible(PG_FUNCTION_ARGS)
1972 {
1973         Oid                     oid = PG_GETARG_OID(0);
1974
1975         PG_RETURN_BOOL(TypeIsVisible(oid));
1976 }
1977
1978 Datum
1979 pg_function_is_visible(PG_FUNCTION_ARGS)
1980 {
1981         Oid                     oid = PG_GETARG_OID(0);
1982
1983         PG_RETURN_BOOL(FunctionIsVisible(oid));
1984 }
1985
1986 Datum
1987 pg_operator_is_visible(PG_FUNCTION_ARGS)
1988 {
1989         Oid                     oid = PG_GETARG_OID(0);
1990
1991         PG_RETURN_BOOL(OperatorIsVisible(oid));
1992 }
1993
1994 Datum
1995 pg_opclass_is_visible(PG_FUNCTION_ARGS)
1996 {
1997         Oid                     oid = PG_GETARG_OID(0);
1998
1999         PG_RETURN_BOOL(OpclassIsVisible(oid));
2000 }
2001
2002 Datum
2003 pg_conversion_is_visible(PG_FUNCTION_ARGS)
2004 {
2005         Oid                     oid = PG_GETARG_OID(0);
2006
2007         PG_RETURN_BOOL(ConversionIsVisible(oid));
2008 }