LCOV - code coverage report
Current view: top level - src/backend/commands - extension.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 853 1057 80.7 %
Date: 2024-04-13 10:11:43 Functions: 42 44 95.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * extension.c
       4             :  *    Commands to manipulate extensions
       5             :  *
       6             :  * Extensions in PostgreSQL allow management of collections of SQL objects.
       7             :  *
       8             :  * All we need internally to manage an extension is an OID so that the
       9             :  * dependent objects can be associated with it.  An extension is created by
      10             :  * populating the pg_extension catalog from a "control" file.
      11             :  * The extension control file is parsed with the same parser we use for
      12             :  * postgresql.conf.  An extension also has an installation script file,
      13             :  * containing SQL commands to create the extension's objects.
      14             :  *
      15             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
      16             :  * Portions Copyright (c) 1994, Regents of the University of California
      17             :  *
      18             :  *
      19             :  * IDENTIFICATION
      20             :  *    src/backend/commands/extension.c
      21             :  *
      22             :  *-------------------------------------------------------------------------
      23             :  */
      24             : #include "postgres.h"
      25             : 
      26             : #include <dirent.h>
      27             : #include <limits.h>
      28             : #include <sys/file.h>
      29             : #include <sys/stat.h>
      30             : #include <unistd.h>
      31             : 
      32             : #include "access/genam.h"
      33             : #include "access/htup_details.h"
      34             : #include "access/relation.h"
      35             : #include "access/table.h"
      36             : #include "access/xact.h"
      37             : #include "catalog/catalog.h"
      38             : #include "catalog/dependency.h"
      39             : #include "catalog/indexing.h"
      40             : #include "catalog/namespace.h"
      41             : #include "catalog/objectaccess.h"
      42             : #include "catalog/pg_authid.h"
      43             : #include "catalog/pg_collation.h"
      44             : #include "catalog/pg_database.h"
      45             : #include "catalog/pg_depend.h"
      46             : #include "catalog/pg_extension.h"
      47             : #include "catalog/pg_namespace.h"
      48             : #include "catalog/pg_type.h"
      49             : #include "commands/alter.h"
      50             : #include "commands/comment.h"
      51             : #include "commands/defrem.h"
      52             : #include "commands/extension.h"
      53             : #include "commands/schemacmds.h"
      54             : #include "funcapi.h"
      55             : #include "mb/pg_wchar.h"
      56             : #include "miscadmin.h"
      57             : #include "storage/fd.h"
      58             : #include "tcop/utility.h"
      59             : #include "utils/acl.h"
      60             : #include "utils/builtins.h"
      61             : #include "utils/conffiles.h"
      62             : #include "utils/fmgroids.h"
      63             : #include "utils/lsyscache.h"
      64             : #include "utils/memutils.h"
      65             : #include "utils/rel.h"
      66             : #include "utils/snapmgr.h"
      67             : #include "utils/varlena.h"
      68             : 
      69             : 
      70             : /* Globally visible state variables */
      71             : bool        creating_extension = false;
      72             : Oid         CurrentExtensionObject = InvalidOid;
      73             : 
      74             : /*
      75             :  * Internal data structure to hold the results of parsing a control file
      76             :  */
      77             : typedef struct ExtensionControlFile
      78             : {
      79             :     char       *name;           /* name of the extension */
      80             :     char       *directory;      /* directory for script files */
      81             :     char       *default_version;    /* default install target version, if any */
      82             :     char       *module_pathname;    /* string to substitute for
      83             :                                      * MODULE_PATHNAME */
      84             :     char       *comment;        /* comment, if any */
      85             :     char       *schema;         /* target schema (allowed if !relocatable) */
      86             :     bool        relocatable;    /* is ALTER EXTENSION SET SCHEMA supported? */
      87             :     bool        superuser;      /* must be superuser to install? */
      88             :     bool        trusted;        /* allow becoming superuser on the fly? */
      89             :     int         encoding;       /* encoding of the script file, or -1 */
      90             :     List       *requires;       /* names of prerequisite extensions */
      91             :     List       *no_relocate;    /* names of prerequisite extensions that
      92             :                                  * should not be relocated */
      93             : } ExtensionControlFile;
      94             : 
      95             : /*
      96             :  * Internal data structure for update path information
      97             :  */
      98             : typedef struct ExtensionVersionInfo
      99             : {
     100             :     char       *name;           /* name of the starting version */
     101             :     List       *reachable;      /* List of ExtensionVersionInfo's */
     102             :     bool        installable;    /* does this version have an install script? */
     103             :     /* working state for Dijkstra's algorithm: */
     104             :     bool        distance_known; /* is distance from start known yet? */
     105             :     int         distance;       /* current worst-case distance estimate */
     106             :     struct ExtensionVersionInfo *previous;  /* current best predecessor */
     107             : } ExtensionVersionInfo;
     108             : 
     109             : /* Local functions */
     110             : static List *find_update_path(List *evi_list,
     111             :                               ExtensionVersionInfo *evi_start,
     112             :                               ExtensionVersionInfo *evi_target,
     113             :                               bool reject_indirect,
     114             :                               bool reinitialize);
     115             : static Oid  get_required_extension(char *reqExtensionName,
     116             :                                    char *extensionName,
     117             :                                    char *origSchemaName,
     118             :                                    bool cascade,
     119             :                                    List *parents,
     120             :                                    bool is_create);
     121             : static void get_available_versions_for_extension(ExtensionControlFile *pcontrol,
     122             :                                                  Tuplestorestate *tupstore,
     123             :                                                  TupleDesc tupdesc);
     124             : static Datum convert_requires_to_datum(List *requires);
     125             : static void ApplyExtensionUpdates(Oid extensionOid,
     126             :                                   ExtensionControlFile *pcontrol,
     127             :                                   const char *initialVersion,
     128             :                                   List *updateVersions,
     129             :                                   char *origSchemaName,
     130             :                                   bool cascade,
     131             :                                   bool is_create);
     132             : static void ExecAlterExtensionContentsRecurse(AlterExtensionContentsStmt *stmt,
     133             :                                               ObjectAddress extension,
     134             :                                               ObjectAddress object);
     135             : static char *read_whole_file(const char *filename, int *length);
     136             : 
     137             : 
     138             : /*
     139             :  * get_extension_oid - given an extension name, look up the OID
     140             :  *
     141             :  * If missing_ok is false, throw an error if extension name not found.  If
     142             :  * true, just return InvalidOid.
     143             :  */
     144             : Oid
     145        2698 : get_extension_oid(const char *extname, bool missing_ok)
     146             : {
     147             :     Oid         result;
     148             :     Relation    rel;
     149             :     SysScanDesc scandesc;
     150             :     HeapTuple   tuple;
     151             :     ScanKeyData entry[1];
     152             : 
     153        2698 :     rel = table_open(ExtensionRelationId, AccessShareLock);
     154             : 
     155        2698 :     ScanKeyInit(&entry[0],
     156             :                 Anum_pg_extension_extname,
     157             :                 BTEqualStrategyNumber, F_NAMEEQ,
     158             :                 CStringGetDatum(extname));
     159             : 
     160        2698 :     scandesc = systable_beginscan(rel, ExtensionNameIndexId, true,
     161             :                                   NULL, 1, entry);
     162             : 
     163        2698 :     tuple = systable_getnext(scandesc);
     164             : 
     165             :     /* We assume that there can be at most one matching tuple */
     166        2698 :     if (HeapTupleIsValid(tuple))
     167        2222 :         result = ((Form_pg_extension) GETSTRUCT(tuple))->oid;
     168             :     else
     169         476 :         result = InvalidOid;
     170             : 
     171        2698 :     systable_endscan(scandesc);
     172             : 
     173        2698 :     table_close(rel, AccessShareLock);
     174             : 
     175        2698 :     if (!OidIsValid(result) && !missing_ok)
     176          12 :         ereport(ERROR,
     177             :                 (errcode(ERRCODE_UNDEFINED_OBJECT),
     178             :                  errmsg("extension \"%s\" does not exist",
     179             :                         extname)));
     180             : 
     181        2686 :     return result;
     182             : }
     183             : 
     184             : /*
     185             :  * get_extension_name - given an extension OID, look up the name
     186             :  *
     187             :  * Returns a palloc'd string, or NULL if no such extension.
     188             :  */
     189             : char *
     190         114 : get_extension_name(Oid ext_oid)
     191             : {
     192             :     char       *result;
     193             :     Relation    rel;
     194             :     SysScanDesc scandesc;
     195             :     HeapTuple   tuple;
     196             :     ScanKeyData entry[1];
     197             : 
     198         114 :     rel = table_open(ExtensionRelationId, AccessShareLock);
     199             : 
     200         114 :     ScanKeyInit(&entry[0],
     201             :                 Anum_pg_extension_oid,
     202             :                 BTEqualStrategyNumber, F_OIDEQ,
     203             :                 ObjectIdGetDatum(ext_oid));
     204             : 
     205         114 :     scandesc = systable_beginscan(rel, ExtensionOidIndexId, true,
     206             :                                   NULL, 1, entry);
     207             : 
     208         114 :     tuple = systable_getnext(scandesc);
     209             : 
     210             :     /* We assume that there can be at most one matching tuple */
     211         114 :     if (HeapTupleIsValid(tuple))
     212          96 :         result = pstrdup(NameStr(((Form_pg_extension) GETSTRUCT(tuple))->extname));
     213             :     else
     214          18 :         result = NULL;
     215             : 
     216         114 :     systable_endscan(scandesc);
     217             : 
     218         114 :     table_close(rel, AccessShareLock);
     219             : 
     220         114 :     return result;
     221             : }
     222             : 
     223             : /*
     224             :  * get_extension_schema - given an extension OID, fetch its extnamespace
     225             :  *
     226             :  * Returns InvalidOid if no such extension.
     227             :  */
     228             : Oid
     229          56 : get_extension_schema(Oid ext_oid)
     230             : {
     231             :     Oid         result;
     232             :     Relation    rel;
     233             :     SysScanDesc scandesc;
     234             :     HeapTuple   tuple;
     235             :     ScanKeyData entry[1];
     236             : 
     237          56 :     rel = table_open(ExtensionRelationId, AccessShareLock);
     238             : 
     239          56 :     ScanKeyInit(&entry[0],
     240             :                 Anum_pg_extension_oid,
     241             :                 BTEqualStrategyNumber, F_OIDEQ,
     242             :                 ObjectIdGetDatum(ext_oid));
     243             : 
     244          56 :     scandesc = systable_beginscan(rel, ExtensionOidIndexId, true,
     245             :                                   NULL, 1, entry);
     246             : 
     247          56 :     tuple = systable_getnext(scandesc);
     248             : 
     249             :     /* We assume that there can be at most one matching tuple */
     250          56 :     if (HeapTupleIsValid(tuple))
     251          56 :         result = ((Form_pg_extension) GETSTRUCT(tuple))->extnamespace;
     252             :     else
     253           0 :         result = InvalidOid;
     254             : 
     255          56 :     systable_endscan(scandesc);
     256             : 
     257          56 :     table_close(rel, AccessShareLock);
     258             : 
     259          56 :     return result;
     260             : }
     261             : 
     262             : /*
     263             :  * Utility functions to check validity of extension and version names
     264             :  */
     265             : static void
     266         446 : check_valid_extension_name(const char *extensionname)
     267             : {
     268         446 :     int         namelen = strlen(extensionname);
     269             : 
     270             :     /*
     271             :      * Disallow empty names (the parser rejects empty identifiers anyway, but
     272             :      * let's check).
     273             :      */
     274         446 :     if (namelen == 0)
     275           0 :         ereport(ERROR,
     276             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     277             :                  errmsg("invalid extension name: \"%s\"", extensionname),
     278             :                  errdetail("Extension names must not be empty.")));
     279             : 
     280             :     /*
     281             :      * No double dashes, since that would make script filenames ambiguous.
     282             :      */
     283         446 :     if (strstr(extensionname, "--"))
     284           0 :         ereport(ERROR,
     285             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     286             :                  errmsg("invalid extension name: \"%s\"", extensionname),
     287             :                  errdetail("Extension names must not contain \"--\".")));
     288             : 
     289             :     /*
     290             :      * No leading or trailing dash either.  (We could probably allow this, but
     291             :      * it would require much care in filename parsing and would make filenames
     292             :      * visually if not formally ambiguous.  Since there's no real-world use
     293             :      * case, let's just forbid it.)
     294             :      */
     295         446 :     if (extensionname[0] == '-' || extensionname[namelen - 1] == '-')
     296           0 :         ereport(ERROR,
     297             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     298             :                  errmsg("invalid extension name: \"%s\"", extensionname),
     299             :                  errdetail("Extension names must not begin or end with \"-\".")));
     300             : 
     301             :     /*
     302             :      * No directory separators either (this is sufficient to prevent ".."
     303             :      * style attacks).
     304             :      */
     305         446 :     if (first_dir_separator(extensionname) != NULL)
     306           0 :         ereport(ERROR,
     307             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     308             :                  errmsg("invalid extension name: \"%s\"", extensionname),
     309             :                  errdetail("Extension names must not contain directory separator characters.")));
     310         446 : }
     311             : 
     312             : static void
     313         468 : check_valid_version_name(const char *versionname)
     314             : {
     315         468 :     int         namelen = strlen(versionname);
     316             : 
     317             :     /*
     318             :      * Disallow empty names (we could possibly allow this, but there seems
     319             :      * little point).
     320             :      */
     321         468 :     if (namelen == 0)
     322           0 :         ereport(ERROR,
     323             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     324             :                  errmsg("invalid extension version name: \"%s\"", versionname),
     325             :                  errdetail("Version names must not be empty.")));
     326             : 
     327             :     /*
     328             :      * No double dashes, since that would make script filenames ambiguous.
     329             :      */
     330         468 :     if (strstr(versionname, "--"))
     331           0 :         ereport(ERROR,
     332             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     333             :                  errmsg("invalid extension version name: \"%s\"", versionname),
     334             :                  errdetail("Version names must not contain \"--\".")));
     335             : 
     336             :     /*
     337             :      * No leading or trailing dash either.
     338             :      */
     339         468 :     if (versionname[0] == '-' || versionname[namelen - 1] == '-')
     340           0 :         ereport(ERROR,
     341             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     342             :                  errmsg("invalid extension version name: \"%s\"", versionname),
     343             :                  errdetail("Version names must not begin or end with \"-\".")));
     344             : 
     345             :     /*
     346             :      * No directory separators either (this is sufficient to prevent ".."
     347             :      * style attacks).
     348             :      */
     349         468 :     if (first_dir_separator(versionname) != NULL)
     350           0 :         ereport(ERROR,
     351             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     352             :                  errmsg("invalid extension version name: \"%s\"", versionname),
     353             :                  errdetail("Version names must not contain directory separator characters.")));
     354         468 : }
     355             : 
     356             : /*
     357             :  * Utility functions to handle extension-related path names
     358             :  */
     359             : static bool
     360       10144 : is_extension_control_filename(const char *filename)
     361             : {
     362       10144 :     const char *extension = strrchr(filename, '.');
     363             : 
     364       10144 :     return (extension != NULL) && (strcmp(extension, ".control") == 0);
     365             : }
     366             : 
     367             : static bool
     368      236482 : is_extension_script_filename(const char *filename)
     369             : {
     370      236482 :     const char *extension = strrchr(filename, '.');
     371             : 
     372      236482 :     return (extension != NULL) && (strcmp(extension, ".sql") == 0);
     373             : }
     374             : 
     375             : static char *
     376        3894 : get_extension_control_directory(void)
     377             : {
     378             :     char        sharepath[MAXPGPATH];
     379             :     char       *result;
     380             : 
     381        3894 :     get_share_path(my_exec_path, sharepath);
     382        3894 :     result = (char *) palloc(MAXPGPATH);
     383        3894 :     snprintf(result, MAXPGPATH, "%s/extension", sharepath);
     384             : 
     385        3894 :     return result;
     386             : }
     387             : 
     388             : static char *
     389        3708 : get_extension_control_filename(const char *extname)
     390             : {
     391             :     char        sharepath[MAXPGPATH];
     392             :     char       *result;
     393             : 
     394        3708 :     get_share_path(my_exec_path, sharepath);
     395        3708 :     result = (char *) palloc(MAXPGPATH);
     396        3708 :     snprintf(result, MAXPGPATH, "%s/extension/%s.control",
     397             :              sharepath, extname);
     398             : 
     399        3708 :     return result;
     400             : }
     401             : 
     402             : static char *
     403        3862 : get_extension_script_directory(ExtensionControlFile *control)
     404             : {
     405             :     char        sharepath[MAXPGPATH];
     406             :     char       *result;
     407             : 
     408             :     /*
     409             :      * The directory parameter can be omitted, absolute, or relative to the
     410             :      * installation's share directory.
     411             :      */
     412        3862 :     if (!control->directory)
     413        3862 :         return get_extension_control_directory();
     414             : 
     415           0 :     if (is_absolute_path(control->directory))
     416           0 :         return pstrdup(control->directory);
     417             : 
     418           0 :     get_share_path(my_exec_path, sharepath);
     419           0 :     result = (char *) palloc(MAXPGPATH);
     420           0 :     snprintf(result, MAXPGPATH, "%s/%s", sharepath, control->directory);
     421             : 
     422           0 :     return result;
     423             : }
     424             : 
     425             : static char *
     426        1834 : get_extension_aux_control_filename(ExtensionControlFile *control,
     427             :                                    const char *version)
     428             : {
     429             :     char       *result;
     430             :     char       *scriptdir;
     431             : 
     432        1834 :     scriptdir = get_extension_script_directory(control);
     433             : 
     434        1834 :     result = (char *) palloc(MAXPGPATH);
     435        1834 :     snprintf(result, MAXPGPATH, "%s/%s--%s.control",
     436             :              scriptdir, control->name, version);
     437             : 
     438        1834 :     pfree(scriptdir);
     439             : 
     440        1834 :     return result;
     441             : }
     442             : 
     443             : static char *
     444        1282 : get_extension_script_filename(ExtensionControlFile *control,
     445             :                               const char *from_version, const char *version)
     446             : {
     447             :     char       *result;
     448             :     char       *scriptdir;
     449             : 
     450        1282 :     scriptdir = get_extension_script_directory(control);
     451             : 
     452        1282 :     result = (char *) palloc(MAXPGPATH);
     453        1282 :     if (from_version)
     454         420 :         snprintf(result, MAXPGPATH, "%s/%s--%s--%s.sql",
     455             :                  scriptdir, control->name, from_version, version);
     456             :     else
     457         862 :         snprintf(result, MAXPGPATH, "%s/%s--%s.sql",
     458             :                  scriptdir, control->name, version);
     459             : 
     460        1282 :     pfree(scriptdir);
     461             : 
     462        1282 :     return result;
     463             : }
     464             : 
     465             : 
     466             : /*
     467             :  * Parse contents of primary or auxiliary control file, and fill in
     468             :  * fields of *control.  We parse primary file if version == NULL,
     469             :  * else the optional auxiliary file for that version.
     470             :  *
     471             :  * Control files are supposed to be very short, half a dozen lines,
     472             :  * so we don't worry about memory allocation risks here.  Also we don't
     473             :  * worry about what encoding it's in; all values are expected to be ASCII.
     474             :  */
     475             : static void
     476        5542 : parse_extension_control_file(ExtensionControlFile *control,
     477             :                              const char *version)
     478             : {
     479             :     char       *filename;
     480             :     FILE       *file;
     481             :     ConfigVariable *item,
     482        5542 :                *head = NULL,
     483        5542 :                *tail = NULL;
     484             : 
     485             :     /*
     486             :      * Locate the file to read.  Auxiliary files are optional.
     487             :      */
     488        5542 :     if (version)
     489        1834 :         filename = get_extension_aux_control_filename(control, version);
     490             :     else
     491        3708 :         filename = get_extension_control_filename(control->name);
     492             : 
     493        5542 :     if ((file = AllocateFile(filename, "r")) == NULL)
     494             :     {
     495        1834 :         if (errno == ENOENT)
     496             :         {
     497             :             /* no complaint for missing auxiliary file */
     498        1834 :             if (version)
     499             :             {
     500        1834 :                 pfree(filename);
     501        1834 :                 return;
     502             :             }
     503             : 
     504             :             /* missing control file indicates extension is not installed */
     505           0 :             ereport(ERROR,
     506             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     507             :                      errmsg("extension \"%s\" is not available", control->name),
     508             :                      errdetail("Could not open extension control file \"%s\": %m.",
     509             :                                filename),
     510             :                      errhint("The extension must first be installed on the system where PostgreSQL is running.")));
     511             :         }
     512           0 :         ereport(ERROR,
     513             :                 (errcode_for_file_access(),
     514             :                  errmsg("could not open extension control file \"%s\": %m",
     515             :                         filename)));
     516             :     }
     517             : 
     518             :     /*
     519             :      * Parse the file content, using GUC's file parsing code.  We need not
     520             :      * check the return value since any errors will be thrown at ERROR level.
     521             :      */
     522        3708 :     (void) ParseConfigFp(file, filename, CONF_FILE_START_DEPTH, ERROR,
     523             :                          &head, &tail);
     524             : 
     525        3708 :     FreeFile(file);
     526             : 
     527             :     /*
     528             :      * Convert the ConfigVariable list into ExtensionControlFile entries.
     529             :      */
     530       20256 :     for (item = head; item != NULL; item = item->next)
     531             :     {
     532       16548 :         if (strcmp(item->name, "directory") == 0)
     533             :         {
     534           0 :             if (version)
     535           0 :                 ereport(ERROR,
     536             :                         (errcode(ERRCODE_SYNTAX_ERROR),
     537             :                          errmsg("parameter \"%s\" cannot be set in a secondary extension control file",
     538             :                                 item->name)));
     539             : 
     540           0 :             control->directory = pstrdup(item->value);
     541             :         }
     542       16548 :         else if (strcmp(item->name, "default_version") == 0)
     543             :         {
     544        3708 :             if (version)
     545           0 :                 ereport(ERROR,
     546             :                         (errcode(ERRCODE_SYNTAX_ERROR),
     547             :                          errmsg("parameter \"%s\" cannot be set in a secondary extension control file",
     548             :                                 item->name)));
     549             : 
     550        3708 :             control->default_version = pstrdup(item->value);
     551             :         }
     552       12840 :         else if (strcmp(item->name, "module_pathname") == 0)
     553             :         {
     554        2958 :             control->module_pathname = pstrdup(item->value);
     555             :         }
     556        9882 :         else if (strcmp(item->name, "comment") == 0)
     557             :         {
     558        3708 :             control->comment = pstrdup(item->value);
     559             :         }
     560        6174 :         else if (strcmp(item->name, "schema") == 0)
     561             :         {
     562         488 :             control->schema = pstrdup(item->value);
     563             :         }
     564        5686 :         else if (strcmp(item->name, "relocatable") == 0)
     565             :         {
     566        3708 :             if (!parse_bool(item->value, &control->relocatable))
     567           0 :                 ereport(ERROR,
     568             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     569             :                          errmsg("parameter \"%s\" requires a Boolean value",
     570             :                                 item->name)));
     571             :         }
     572        1978 :         else if (strcmp(item->name, "superuser") == 0)
     573             :         {
     574         374 :             if (!parse_bool(item->value, &control->superuser))
     575           0 :                 ereport(ERROR,
     576             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     577             :                          errmsg("parameter \"%s\" requires a Boolean value",
     578             :                                 item->name)));
     579             :         }
     580        1604 :         else if (strcmp(item->name, "trusted") == 0)
     581             :         {
     582         960 :             if (!parse_bool(item->value, &control->trusted))
     583           0 :                 ereport(ERROR,
     584             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     585             :                          errmsg("parameter \"%s\" requires a Boolean value",
     586             :                                 item->name)));
     587             :         }
     588         644 :         else if (strcmp(item->name, "encoding") == 0)
     589             :         {
     590           0 :             control->encoding = pg_valid_server_encoding(item->value);
     591           0 :             if (control->encoding < 0)
     592           0 :                 ereport(ERROR,
     593             :                         (errcode(ERRCODE_UNDEFINED_OBJECT),
     594             :                          errmsg("\"%s\" is not a valid encoding name",
     595             :                                 item->value)));
     596             :         }
     597         644 :         else if (strcmp(item->name, "requires") == 0)
     598             :         {
     599             :             /* Need a modifiable copy of string */
     600         604 :             char       *rawnames = pstrdup(item->value);
     601             : 
     602             :             /* Parse string into list of identifiers */
     603         604 :             if (!SplitIdentifierString(rawnames, ',', &control->requires))
     604             :             {
     605             :                 /* syntax error in name list */
     606           0 :                 ereport(ERROR,
     607             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     608             :                          errmsg("parameter \"%s\" must be a list of extension names",
     609             :                                 item->name)));
     610             :             }
     611             :         }
     612          40 :         else if (strcmp(item->name, "no_relocate") == 0)
     613             :         {
     614             :             /* Need a modifiable copy of string */
     615          40 :             char       *rawnames = pstrdup(item->value);
     616             : 
     617             :             /* Parse string into list of identifiers */
     618          40 :             if (!SplitIdentifierString(rawnames, ',', &control->no_relocate))
     619             :             {
     620             :                 /* syntax error in name list */
     621           0 :                 ereport(ERROR,
     622             :                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     623             :                          errmsg("parameter \"%s\" must be a list of extension names",
     624             :                                 item->name)));
     625             :             }
     626             :         }
     627             :         else
     628           0 :             ereport(ERROR,
     629             :                     (errcode(ERRCODE_SYNTAX_ERROR),
     630             :                      errmsg("unrecognized parameter \"%s\" in file \"%s\"",
     631             :                             item->name, filename)));
     632             :     }
     633             : 
     634        3708 :     FreeConfigVariables(head);
     635             : 
     636        3708 :     if (control->relocatable && control->schema != NULL)
     637           0 :         ereport(ERROR,
     638             :                 (errcode(ERRCODE_SYNTAX_ERROR),
     639             :                  errmsg("parameter \"schema\" cannot be specified when \"relocatable\" is true")));
     640             : 
     641        3708 :     pfree(filename);
     642             : }
     643             : 
     644             : /*
     645             :  * Read the primary control file for the specified extension.
     646             :  */
     647             : static ExtensionControlFile *
     648        3708 : read_extension_control_file(const char *extname)
     649             : {
     650             :     ExtensionControlFile *control;
     651             : 
     652             :     /*
     653             :      * Set up default values.  Pointer fields are initially null.
     654             :      */
     655        3708 :     control = (ExtensionControlFile *) palloc0(sizeof(ExtensionControlFile));
     656        3708 :     control->name = pstrdup(extname);
     657        3708 :     control->relocatable = false;
     658        3708 :     control->superuser = true;
     659        3708 :     control->trusted = false;
     660        3708 :     control->encoding = -1;
     661             : 
     662             :     /*
     663             :      * Parse the primary control file.
     664             :      */
     665        3708 :     parse_extension_control_file(control, NULL);
     666             : 
     667        3708 :     return control;
     668             : }
     669             : 
     670             : /*
     671             :  * Read the auxiliary control file for the specified extension and version.
     672             :  *
     673             :  * Returns a new modified ExtensionControlFile struct; the original struct
     674             :  * (reflecting just the primary control file) is not modified.
     675             :  */
     676             : static ExtensionControlFile *
     677        1834 : read_extension_aux_control_file(const ExtensionControlFile *pcontrol,
     678             :                                 const char *version)
     679             : {
     680             :     ExtensionControlFile *acontrol;
     681             : 
     682             :     /*
     683             :      * Flat-copy the struct.  Pointer fields share values with original.
     684             :      */
     685        1834 :     acontrol = (ExtensionControlFile *) palloc(sizeof(ExtensionControlFile));
     686        1834 :     memcpy(acontrol, pcontrol, sizeof(ExtensionControlFile));
     687             : 
     688             :     /*
     689             :      * Parse the auxiliary control file, overwriting struct fields
     690             :      */
     691        1834 :     parse_extension_control_file(acontrol, version);
     692             : 
     693        1834 :     return acontrol;
     694             : }
     695             : 
     696             : /*
     697             :  * Read an SQL script file into a string, and convert to database encoding
     698             :  */
     699             : static char *
     700         840 : read_extension_script_file(const ExtensionControlFile *control,
     701             :                            const char *filename)
     702             : {
     703             :     int         src_encoding;
     704             :     char       *src_str;
     705             :     char       *dest_str;
     706             :     int         len;
     707             : 
     708         840 :     src_str = read_whole_file(filename, &len);
     709             : 
     710             :     /* use database encoding if not given */
     711         840 :     if (control->encoding < 0)
     712         840 :         src_encoding = GetDatabaseEncoding();
     713             :     else
     714           0 :         src_encoding = control->encoding;
     715             : 
     716             :     /* make sure that source string is valid in the expected encoding */
     717         840 :     (void) pg_verify_mbstr(src_encoding, src_str, len, false);
     718             : 
     719             :     /*
     720             :      * Convert the encoding to the database encoding. read_whole_file
     721             :      * null-terminated the string, so if no conversion happens the string is
     722             :      * valid as is.
     723             :      */
     724         840 :     dest_str = pg_any_to_server(src_str, len, src_encoding);
     725             : 
     726         840 :     return dest_str;
     727             : }
     728             : 
     729             : /*
     730             :  * Execute given SQL string.
     731             :  *
     732             :  * Note: it's tempting to just use SPI to execute the string, but that does
     733             :  * not work very well.  The really serious problem is that SPI will parse,
     734             :  * analyze, and plan the whole string before executing any of it; of course
     735             :  * this fails if there are any plannable statements referring to objects
     736             :  * created earlier in the script.  A lesser annoyance is that SPI insists
     737             :  * on printing the whole string as errcontext in case of any error, and that
     738             :  * could be very long.
     739             :  */
     740             : static void
     741         836 : execute_sql_string(const char *sql)
     742             : {
     743             :     List       *raw_parsetree_list;
     744             :     DestReceiver *dest;
     745             :     ListCell   *lc1;
     746             : 
     747             :     /*
     748             :      * Parse the SQL string into a list of raw parse trees.
     749             :      */
     750         836 :     raw_parsetree_list = pg_parse_query(sql);
     751             : 
     752             :     /* All output from SELECTs goes to the bit bucket */
     753         836 :     dest = CreateDestReceiver(DestNone);
     754             : 
     755             :     /*
     756             :      * Do parse analysis, rule rewrite, planning, and execution for each raw
     757             :      * parsetree.  We must fully execute each query before beginning parse
     758             :      * analysis on the next one, since there may be interdependencies.
     759             :      */
     760       10374 :     foreach(lc1, raw_parsetree_list)
     761             :     {
     762        9560 :         RawStmt    *parsetree = lfirst_node(RawStmt, lc1);
     763             :         MemoryContext per_parsetree_context,
     764             :                     oldcontext;
     765             :         List       *stmt_list;
     766             :         ListCell   *lc2;
     767             : 
     768             :         /*
     769             :          * We do the work for each parsetree in a short-lived context, to
     770             :          * limit the memory used when there are many commands in the string.
     771             :          */
     772             :         per_parsetree_context =
     773        9560 :             AllocSetContextCreate(CurrentMemoryContext,
     774             :                                   "execute_sql_string per-statement context",
     775             :                                   ALLOCSET_DEFAULT_SIZES);
     776        9560 :         oldcontext = MemoryContextSwitchTo(per_parsetree_context);
     777             : 
     778             :         /* Be sure parser can see any DDL done so far */
     779        9560 :         CommandCounterIncrement();
     780             : 
     781        9560 :         stmt_list = pg_analyze_and_rewrite_fixedparams(parsetree,
     782             :                                                        sql,
     783             :                                                        NULL,
     784             :                                                        0,
     785             :                                                        NULL);
     786        9560 :         stmt_list = pg_plan_queries(stmt_list, sql, CURSOR_OPT_PARALLEL_OK, NULL);
     787             : 
     788       19098 :         foreach(lc2, stmt_list)
     789             :         {
     790        9560 :             PlannedStmt *stmt = lfirst_node(PlannedStmt, lc2);
     791             : 
     792        9560 :             CommandCounterIncrement();
     793             : 
     794        9560 :             PushActiveSnapshot(GetTransactionSnapshot());
     795             : 
     796        9560 :             if (stmt->utilityStmt == NULL)
     797             :             {
     798             :                 QueryDesc  *qdesc;
     799             : 
     800          12 :                 qdesc = CreateQueryDesc(stmt,
     801             :                                         sql,
     802             :                                         GetActiveSnapshot(), NULL,
     803             :                                         dest, NULL, NULL, 0);
     804             : 
     805          12 :                 ExecutorStart(qdesc, 0);
     806          12 :                 ExecutorRun(qdesc, ForwardScanDirection, 0, true);
     807          12 :                 ExecutorFinish(qdesc);
     808          12 :                 ExecutorEnd(qdesc);
     809             : 
     810          12 :                 FreeQueryDesc(qdesc);
     811             :             }
     812             :             else
     813             :             {
     814        9548 :                 if (IsA(stmt->utilityStmt, TransactionStmt))
     815           0 :                     ereport(ERROR,
     816             :                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     817             :                              errmsg("transaction control statements are not allowed within an extension script")));
     818             : 
     819        9548 :                 ProcessUtility(stmt,
     820             :                                sql,
     821             :                                false,
     822             :                                PROCESS_UTILITY_QUERY,
     823             :                                NULL,
     824             :                                NULL,
     825             :                                dest,
     826             :                                NULL);
     827             :             }
     828             : 
     829        9538 :             PopActiveSnapshot();
     830             :         }
     831             : 
     832             :         /* Clean up per-parsetree context. */
     833        9538 :         MemoryContextSwitchTo(oldcontext);
     834        9538 :         MemoryContextDelete(per_parsetree_context);
     835             :     }
     836             : 
     837             :     /* Be sure to advance the command counter after the last script command */
     838         814 :     CommandCounterIncrement();
     839         814 : }
     840             : 
     841             : /*
     842             :  * Policy function: is the given extension trusted for installation by a
     843             :  * non-superuser?
     844             :  *
     845             :  * (Update the errhint logic below if you change this.)
     846             :  */
     847             : static bool
     848          14 : extension_is_trusted(ExtensionControlFile *control)
     849             : {
     850             :     AclResult   aclresult;
     851             : 
     852             :     /* Never trust unless extension's control file says it's okay */
     853          14 :     if (!control->trusted)
     854           4 :         return false;
     855             :     /* Allow if user has CREATE privilege on current database */
     856          10 :     aclresult = object_aclcheck(DatabaseRelationId, MyDatabaseId, GetUserId(), ACL_CREATE);
     857          10 :     if (aclresult == ACLCHECK_OK)
     858           8 :         return true;
     859           2 :     return false;
     860             : }
     861             : 
     862             : /*
     863             :  * Execute the appropriate script file for installing or updating the extension
     864             :  *
     865             :  * If from_version isn't NULL, it's an update
     866             :  *
     867             :  * Note: requiredSchemas must be one-for-one with the control->requires list
     868             :  */
     869             : static void
     870         846 : execute_extension_script(Oid extensionOid, ExtensionControlFile *control,
     871             :                          const char *from_version,
     872             :                          const char *version,
     873             :                          List *requiredSchemas,
     874             :                          const char *schemaName, Oid schemaOid)
     875             : {
     876         846 :     bool        switch_to_superuser = false;
     877             :     char       *filename;
     878         846 :     Oid         save_userid = 0;
     879         846 :     int         save_sec_context = 0;
     880             :     int         save_nestlevel;
     881             :     StringInfoData pathbuf;
     882             :     ListCell   *lc;
     883             :     ListCell   *lc2;
     884             : 
     885             :     /*
     886             :      * Enforce superuser-ness if appropriate.  We postpone these checks until
     887             :      * here so that the control flags are correctly associated with the right
     888             :      * script(s) if they happen to be set in secondary control files.
     889             :      */
     890         846 :     if (control->superuser && !superuser())
     891             :     {
     892          14 :         if (extension_is_trusted(control))
     893           8 :             switch_to_superuser = true;
     894           6 :         else if (from_version == NULL)
     895           6 :             ereport(ERROR,
     896             :                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
     897             :                      errmsg("permission denied to create extension \"%s\"",
     898             :                             control->name),
     899             :                      control->trusted
     900             :                      ? errhint("Must have CREATE privilege on current database to create this extension.")
     901             :                      : errhint("Must be superuser to create this extension.")));
     902             :         else
     903           0 :             ereport(ERROR,
     904             :                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
     905             :                      errmsg("permission denied to update extension \"%s\"",
     906             :                             control->name),
     907             :                      control->trusted
     908             :                      ? errhint("Must have CREATE privilege on current database to update this extension.")
     909             :                      : errhint("Must be superuser to update this extension.")));
     910             :     }
     911             : 
     912         840 :     filename = get_extension_script_filename(control, from_version, version);
     913             : 
     914         840 :     if (from_version == NULL)
     915         420 :         elog(DEBUG1, "executing extension script for \"%s\" version '%s'", control->name, version);
     916             :     else
     917         420 :         elog(DEBUG1, "executing extension script for \"%s\" update from version '%s' to '%s'", control->name, from_version, version);
     918             : 
     919             :     /*
     920             :      * If installing a trusted extension on behalf of a non-superuser, become
     921             :      * the bootstrap superuser.  (This switch will be cleaned up automatically
     922             :      * if the transaction aborts, as will the GUC changes below.)
     923             :      */
     924         840 :     if (switch_to_superuser)
     925             :     {
     926           8 :         GetUserIdAndSecContext(&save_userid, &save_sec_context);
     927           8 :         SetUserIdAndSecContext(BOOTSTRAP_SUPERUSERID,
     928             :                                save_sec_context | SECURITY_LOCAL_USERID_CHANGE);
     929             :     }
     930             : 
     931             :     /*
     932             :      * Force client_min_messages and log_min_messages to be at least WARNING,
     933             :      * so that we won't spam the user with useless NOTICE messages from common
     934             :      * script actions like creating shell types.
     935             :      *
     936             :      * We use the equivalent of a function SET option to allow the setting to
     937             :      * persist for exactly the duration of the script execution.  guc.c also
     938             :      * takes care of undoing the setting on error.
     939             :      *
     940             :      * log_min_messages can't be set by ordinary users, so for that one we
     941             :      * pretend to be superuser.
     942             :      */
     943         840 :     save_nestlevel = NewGUCNestLevel();
     944             : 
     945         840 :     if (client_min_messages < WARNING)
     946         836 :         (void) set_config_option("client_min_messages", "warning",
     947             :                                  PGC_USERSET, PGC_S_SESSION,
     948             :                                  GUC_ACTION_SAVE, true, 0, false);
     949         840 :     if (log_min_messages < WARNING)
     950           4 :         (void) set_config_option_ext("log_min_messages", "warning",
     951             :                                      PGC_SUSET, PGC_S_SESSION,
     952             :                                      BOOTSTRAP_SUPERUSERID,
     953             :                                      GUC_ACTION_SAVE, true, 0, false);
     954             : 
     955             :     /*
     956             :      * Similarly disable check_function_bodies, to ensure that SQL functions
     957             :      * won't be parsed during creation.
     958             :      */
     959         840 :     if (check_function_bodies)
     960         840 :         (void) set_config_option("check_function_bodies", "off",
     961             :                                  PGC_USERSET, PGC_S_SESSION,
     962             :                                  GUC_ACTION_SAVE, true, 0, false);
     963             : 
     964             :     /*
     965             :      * Set up the search path to have the target schema first, making it be
     966             :      * the default creation target namespace.  Then add the schemas of any
     967             :      * prerequisite extensions, unless they are in pg_catalog which would be
     968             :      * searched anyway.  (Listing pg_catalog explicitly in a non-first
     969             :      * position would be bad for security.)  Finally add pg_temp to ensure
     970             :      * that temp objects can't take precedence over others.
     971             :      */
     972         840 :     initStringInfo(&pathbuf);
     973         840 :     appendStringInfoString(&pathbuf, quote_identifier(schemaName));
     974         892 :     foreach(lc, requiredSchemas)
     975             :     {
     976          52 :         Oid         reqschema = lfirst_oid(lc);
     977          52 :         char       *reqname = get_namespace_name(reqschema);
     978             : 
     979          52 :         if (reqname && strcmp(reqname, "pg_catalog") != 0)
     980          32 :             appendStringInfo(&pathbuf, ", %s", quote_identifier(reqname));
     981             :     }
     982         840 :     appendStringInfoString(&pathbuf, ", pg_temp");
     983             : 
     984         840 :     (void) set_config_option("search_path", pathbuf.data,
     985             :                              PGC_USERSET, PGC_S_SESSION,
     986             :                              GUC_ACTION_SAVE, true, 0, false);
     987             : 
     988             :     /*
     989             :      * Set creating_extension and related variables so that
     990             :      * recordDependencyOnCurrentExtension and other functions do the right
     991             :      * things.  On failure, ensure we reset these variables.
     992             :      */
     993         840 :     creating_extension = true;
     994         840 :     CurrentExtensionObject = extensionOid;
     995         840 :     PG_TRY();
     996             :     {
     997         840 :         char       *c_sql = read_extension_script_file(control, filename);
     998             :         Datum       t_sql;
     999             : 
    1000             :         /*
    1001             :          * We filter each substitution through quote_identifier().  When the
    1002             :          * arg contains one of the following characters, no one collection of
    1003             :          * quoting can work inside $$dollar-quoted string literals$$,
    1004             :          * 'single-quoted string literals', and outside of any literal.  To
    1005             :          * avoid a security snare for extension authors, error on substitution
    1006             :          * for arguments containing these.
    1007             :          */
    1008         840 :         const char *quoting_relevant_chars = "\"$'\\";
    1009             : 
    1010             :         /* We use various functions that want to operate on text datums */
    1011         840 :         t_sql = CStringGetTextDatum(c_sql);
    1012             : 
    1013             :         /*
    1014             :          * Reduce any lines beginning with "\echo" to empty.  This allows
    1015             :          * scripts to contain messages telling people not to run them via
    1016             :          * psql, which has been found to be necessary due to old habits.
    1017             :          */
    1018         840 :         t_sql = DirectFunctionCall4Coll(textregexreplace,
    1019             :                                         C_COLLATION_OID,
    1020             :                                         t_sql,
    1021         840 :                                         CStringGetTextDatum("^\\\\echo.*$"),
    1022         840 :                                         CStringGetTextDatum(""),
    1023         840 :                                         CStringGetTextDatum("ng"));
    1024             : 
    1025             :         /*
    1026             :          * If the script uses @extowner@, substitute the calling username.
    1027             :          */
    1028         840 :         if (strstr(c_sql, "@extowner@"))
    1029             :         {
    1030          92 :             Oid         uid = switch_to_superuser ? save_userid : GetUserId();
    1031          92 :             const char *userName = GetUserNameFromId(uid, false);
    1032          92 :             const char *qUserName = quote_identifier(userName);
    1033             : 
    1034          92 :             t_sql = DirectFunctionCall3Coll(replace_text,
    1035             :                                             C_COLLATION_OID,
    1036             :                                             t_sql,
    1037          92 :                                             CStringGetTextDatum("@extowner@"),
    1038          92 :                                             CStringGetTextDatum(qUserName));
    1039          92 :             if (strpbrk(userName, quoting_relevant_chars))
    1040           0 :                 ereport(ERROR,
    1041             :                         (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
    1042             :                          errmsg("invalid character in extension owner: must not contain any of \"%s\"",
    1043             :                                 quoting_relevant_chars)));
    1044             :         }
    1045             : 
    1046             :         /*
    1047             :          * If it's not relocatable, substitute the target schema name for
    1048             :          * occurrences of @extschema@.
    1049             :          *
    1050             :          * For a relocatable extension, we needn't do this.  There cannot be
    1051             :          * any need for @extschema@, else it wouldn't be relocatable.
    1052             :          */
    1053         840 :         if (!control->relocatable)
    1054             :         {
    1055         130 :             Datum       old = t_sql;
    1056         130 :             const char *qSchemaName = quote_identifier(schemaName);
    1057             : 
    1058         130 :             t_sql = DirectFunctionCall3Coll(replace_text,
    1059             :                                             C_COLLATION_OID,
    1060             :                                             t_sql,
    1061         130 :                                             CStringGetTextDatum("@extschema@"),
    1062         130 :                                             CStringGetTextDatum(qSchemaName));
    1063         130 :             if (t_sql != old && strpbrk(schemaName, quoting_relevant_chars))
    1064           2 :                 ereport(ERROR,
    1065             :                         (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
    1066             :                          errmsg("invalid character in extension \"%s\" schema: must not contain any of \"%s\"",
    1067             :                                 control->name, quoting_relevant_chars)));
    1068             :         }
    1069             : 
    1070             :         /*
    1071             :          * Likewise, substitute required extensions' schema names for
    1072             :          * occurrences of @extschema:extension_name@.
    1073             :          */
    1074             :         Assert(list_length(control->requires) == list_length(requiredSchemas));
    1075         888 :         forboth(lc, control->requires, lc2, requiredSchemas)
    1076             :         {
    1077          52 :             Datum       old = t_sql;
    1078          52 :             char       *reqextname = (char *) lfirst(lc);
    1079          52 :             Oid         reqschema = lfirst_oid(lc2);
    1080          52 :             char       *schemaName = get_namespace_name(reqschema);
    1081          52 :             const char *qSchemaName = quote_identifier(schemaName);
    1082             :             char       *repltoken;
    1083             : 
    1084          52 :             repltoken = psprintf("@extschema:%s@", reqextname);
    1085          52 :             t_sql = DirectFunctionCall3Coll(replace_text,
    1086             :                                             C_COLLATION_OID,
    1087             :                                             t_sql,
    1088          52 :                                             CStringGetTextDatum(repltoken),
    1089          52 :                                             CStringGetTextDatum(qSchemaName));
    1090          52 :             if (t_sql != old && strpbrk(schemaName, quoting_relevant_chars))
    1091           2 :                 ereport(ERROR,
    1092             :                         (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
    1093             :                          errmsg("invalid character in extension \"%s\" schema: must not contain any of \"%s\"",
    1094             :                                 reqextname, quoting_relevant_chars)));
    1095             :         }
    1096             : 
    1097             :         /*
    1098             :          * If module_pathname was set in the control file, substitute its
    1099             :          * value for occurrences of MODULE_PATHNAME.
    1100             :          */
    1101         836 :         if (control->module_pathname)
    1102             :         {
    1103         752 :             t_sql = DirectFunctionCall3Coll(replace_text,
    1104             :                                             C_COLLATION_OID,
    1105             :                                             t_sql,
    1106         752 :                                             CStringGetTextDatum("MODULE_PATHNAME"),
    1107         752 :                                             CStringGetTextDatum(control->module_pathname));
    1108             :         }
    1109             : 
    1110             :         /* And now back to C string */
    1111         836 :         c_sql = text_to_cstring(DatumGetTextPP(t_sql));
    1112             : 
    1113         836 :         execute_sql_string(c_sql);
    1114             :     }
    1115          26 :     PG_FINALLY();
    1116             :     {
    1117         840 :         creating_extension = false;
    1118         840 :         CurrentExtensionObject = InvalidOid;
    1119             :     }
    1120         840 :     PG_END_TRY();
    1121             : 
    1122             :     /*
    1123             :      * Restore the GUC variables we set above.
    1124             :      */
    1125         814 :     AtEOXact_GUC(true, save_nestlevel);
    1126             : 
    1127             :     /*
    1128             :      * Restore authentication state if needed.
    1129             :      */
    1130         814 :     if (switch_to_superuser)
    1131           8 :         SetUserIdAndSecContext(save_userid, save_sec_context);
    1132         814 : }
    1133             : 
    1134             : /*
    1135             :  * Find or create an ExtensionVersionInfo for the specified version name
    1136             :  *
    1137             :  * Currently, we just use a List of the ExtensionVersionInfo's.  Searching
    1138             :  * for them therefore uses about O(N^2) time when there are N versions of
    1139             :  * the extension.  We could change the data structure to a hash table if
    1140             :  * this ever becomes a bottleneck.
    1141             :  */
    1142             : static ExtensionVersionInfo *
    1143        3892 : get_ext_ver_info(const char *versionname, List **evi_list)
    1144             : {
    1145             :     ExtensionVersionInfo *evi;
    1146             :     ListCell   *lc;
    1147             : 
    1148       15278 :     foreach(lc, *evi_list)
    1149             :     {
    1150       13042 :         evi = (ExtensionVersionInfo *) lfirst(lc);
    1151       13042 :         if (strcmp(evi->name, versionname) == 0)
    1152        1656 :             return evi;
    1153             :     }
    1154             : 
    1155        2236 :     evi = (ExtensionVersionInfo *) palloc(sizeof(ExtensionVersionInfo));
    1156        2236 :     evi->name = pstrdup(versionname);
    1157        2236 :     evi->reachable = NIL;
    1158        2236 :     evi->installable = false;
    1159             :     /* initialize for later application of Dijkstra's algorithm */
    1160        2236 :     evi->distance_known = false;
    1161        2236 :     evi->distance = INT_MAX;
    1162        2236 :     evi->previous = NULL;
    1163             : 
    1164        2236 :     *evi_list = lappend(*evi_list, evi);
    1165             : 
    1166        2236 :     return evi;
    1167             : }
    1168             : 
    1169             : /*
    1170             :  * Locate the nearest unprocessed ExtensionVersionInfo
    1171             :  *
    1172             :  * This part of the algorithm is also about O(N^2).  A priority queue would
    1173             :  * make it much faster, but for now there's no need.
    1174             :  */
    1175             : static ExtensionVersionInfo *
    1176        3266 : get_nearest_unprocessed_vertex(List *evi_list)
    1177             : {
    1178        3266 :     ExtensionVersionInfo *evi = NULL;
    1179             :     ListCell   *lc;
    1180             : 
    1181       29590 :     foreach(lc, evi_list)
    1182             :     {
    1183       26324 :         ExtensionVersionInfo *evi2 = (ExtensionVersionInfo *) lfirst(lc);
    1184             : 
    1185             :         /* only vertices whose distance is still uncertain are candidates */
    1186       26324 :         if (evi2->distance_known)
    1187        6758 :             continue;
    1188             :         /* remember the closest such vertex */
    1189       19566 :         if (evi == NULL ||
    1190       16300 :             evi->distance > evi2->distance)
    1191        5262 :             evi = evi2;
    1192             :     }
    1193             : 
    1194        3266 :     return evi;
    1195             : }
    1196             : 
    1197             : /*
    1198             :  * Obtain information about the set of update scripts available for the
    1199             :  * specified extension.  The result is a List of ExtensionVersionInfo
    1200             :  * structs, each with a subsidiary list of the ExtensionVersionInfos for
    1201             :  * the versions that can be reached in one step from that version.
    1202             :  */
    1203             : static List *
    1204         746 : get_ext_ver_list(ExtensionControlFile *control)
    1205             : {
    1206         746 :     List       *evi_list = NIL;
    1207         746 :     int         extnamelen = strlen(control->name);
    1208             :     char       *location;
    1209             :     DIR        *dir;
    1210             :     struct dirent *de;
    1211             : 
    1212         746 :     location = get_extension_script_directory(control);
    1213         746 :     dir = AllocateDir(location);
    1214      237228 :     while ((de = ReadDir(dir, location)) != NULL)
    1215             :     {
    1216             :         char       *vername;
    1217             :         char       *vername2;
    1218             :         ExtensionVersionInfo *evi;
    1219             :         ExtensionVersionInfo *evi2;
    1220             : 
    1221             :         /* must be a .sql file ... */
    1222      236482 :         if (!is_extension_script_filename(de->d_name))
    1223       76838 :             continue;
    1224             : 
    1225             :         /* ... matching extension name followed by separator */
    1226      159644 :         if (strncmp(de->d_name, control->name, extnamelen) != 0 ||
    1227        2336 :             de->d_name[extnamelen] != '-' ||
    1228        2236 :             de->d_name[extnamelen + 1] != '-')
    1229      157408 :             continue;
    1230             : 
    1231             :         /* extract version name(s) from 'extname--something.sql' filename */
    1232        2236 :         vername = pstrdup(de->d_name + extnamelen + 2);
    1233        2236 :         *strrchr(vername, '.') = '\0';
    1234        2236 :         vername2 = strstr(vername, "--");
    1235        2236 :         if (!vername2)
    1236             :         {
    1237             :             /* It's an install, not update, script; record its version name */
    1238         746 :             evi = get_ext_ver_info(vername, &evi_list);
    1239         746 :             evi->installable = true;
    1240         746 :             continue;
    1241             :         }
    1242        1490 :         *vername2 = '\0';       /* terminate first version */
    1243        1490 :         vername2 += 2;          /* and point to second */
    1244             : 
    1245             :         /* if there's a third --, it's bogus, ignore it */
    1246        1490 :         if (strstr(vername2, "--"))
    1247           0 :             continue;
    1248             : 
    1249             :         /* Create ExtensionVersionInfos and link them together */
    1250        1490 :         evi = get_ext_ver_info(vername, &evi_list);
    1251        1490 :         evi2 = get_ext_ver_info(vername2, &evi_list);
    1252        1490 :         evi->reachable = lappend(evi->reachable, evi2);
    1253             :     }
    1254         746 :     FreeDir(dir);
    1255             : 
    1256         746 :     return evi_list;
    1257             : }
    1258             : 
    1259             : /*
    1260             :  * Given an initial and final version name, identify the sequence of update
    1261             :  * scripts that have to be applied to perform that update.
    1262             :  *
    1263             :  * Result is a List of names of versions to transition through (the initial
    1264             :  * version is *not* included).
    1265             :  */
    1266             : static List *
    1267          26 : identify_update_path(ExtensionControlFile *control,
    1268             :                      const char *oldVersion, const char *newVersion)
    1269             : {
    1270             :     List       *result;
    1271             :     List       *evi_list;
    1272             :     ExtensionVersionInfo *evi_start;
    1273             :     ExtensionVersionInfo *evi_target;
    1274             : 
    1275             :     /* Extract the version update graph from the script directory */
    1276          26 :     evi_list = get_ext_ver_list(control);
    1277             : 
    1278             :     /* Initialize start and end vertices */
    1279          26 :     evi_start = get_ext_ver_info(oldVersion, &evi_list);
    1280          26 :     evi_target = get_ext_ver_info(newVersion, &evi_list);
    1281             : 
    1282             :     /* Find shortest path */
    1283          26 :     result = find_update_path(evi_list, evi_start, evi_target, false, false);
    1284             : 
    1285          26 :     if (result == NIL)
    1286           0 :         ereport(ERROR,
    1287             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1288             :                  errmsg("extension \"%s\" has no update path from version \"%s\" to version \"%s\"",
    1289             :                         control->name, oldVersion, newVersion)));
    1290             : 
    1291          26 :     return result;
    1292             : }
    1293             : 
    1294             : /*
    1295             :  * Apply Dijkstra's algorithm to find the shortest path from evi_start to
    1296             :  * evi_target.
    1297             :  *
    1298             :  * If reject_indirect is true, ignore paths that go through installable
    1299             :  * versions.  This saves work when the caller will consider starting from
    1300             :  * all installable versions anyway.
    1301             :  *
    1302             :  * If reinitialize is false, assume the ExtensionVersionInfo list has not
    1303             :  * been used for this before, and the initialization done by get_ext_ver_info
    1304             :  * is still good.  Otherwise, reinitialize all transient fields used here.
    1305             :  *
    1306             :  * Result is a List of names of versions to transition through (the initial
    1307             :  * version is *not* included).  Returns NIL if no such path.
    1308             :  */
    1309             : static List *
    1310         818 : find_update_path(List *evi_list,
    1311             :                  ExtensionVersionInfo *evi_start,
    1312             :                  ExtensionVersionInfo *evi_target,
    1313             :                  bool reject_indirect,
    1314             :                  bool reinitialize)
    1315             : {
    1316             :     List       *result;
    1317             :     ExtensionVersionInfo *evi;
    1318             :     ListCell   *lc;
    1319             : 
    1320             :     /* Caller error if start == target */
    1321             :     Assert(evi_start != evi_target);
    1322             :     /* Caller error if reject_indirect and target is installable */
    1323             :     Assert(!(reject_indirect && evi_target->installable));
    1324             : 
    1325         818 :     if (reinitialize)
    1326             :     {
    1327        6108 :         foreach(lc, evi_list)
    1328             :         {
    1329        5316 :             evi = (ExtensionVersionInfo *) lfirst(lc);
    1330        5316 :             evi->distance_known = false;
    1331        5316 :             evi->distance = INT_MAX;
    1332        5316 :             evi->previous = NULL;
    1333             :         }
    1334             :     }
    1335             : 
    1336         818 :     evi_start->distance = 0;
    1337             : 
    1338        3266 :     while ((evi = get_nearest_unprocessed_vertex(evi_list)) != NULL)
    1339             :     {
    1340        3266 :         if (evi->distance == INT_MAX)
    1341         312 :             break;              /* all remaining vertices are unreachable */
    1342        2954 :         evi->distance_known = true;
    1343        2954 :         if (evi == evi_target)
    1344         506 :             break;              /* found shortest path to target */
    1345        4584 :         foreach(lc, evi->reachable)
    1346             :         {
    1347        2136 :             ExtensionVersionInfo *evi2 = (ExtensionVersionInfo *) lfirst(lc);
    1348             :             int         newdist;
    1349             : 
    1350             :             /* if reject_indirect, treat installable versions as unreachable */
    1351        2136 :             if (reject_indirect && evi2->installable)
    1352           0 :                 continue;
    1353        2136 :             newdist = evi->distance + 1;
    1354        2136 :             if (newdist < evi2->distance)
    1355             :             {
    1356        2136 :                 evi2->distance = newdist;
    1357        2136 :                 evi2->previous = evi;
    1358             :             }
    1359           0 :             else if (newdist == evi2->distance &&
    1360           0 :                      evi2->previous != NULL &&
    1361           0 :                      strcmp(evi->name, evi2->previous->name) < 0)
    1362             :             {
    1363             :                 /*
    1364             :                  * Break ties in favor of the version name that comes first
    1365             :                  * according to strcmp().  This behavior is undocumented and
    1366             :                  * users shouldn't rely on it.  We do it just to ensure that
    1367             :                  * if there is a tie, the update path that is chosen does not
    1368             :                  * depend on random factors like the order in which directory
    1369             :                  * entries get visited.
    1370             :                  */
    1371           0 :                 evi2->previous = evi;
    1372             :             }
    1373             :         }
    1374             :     }
    1375             : 
    1376             :     /* Return NIL if target is not reachable from start */
    1377         818 :     if (!evi_target->distance_known)
    1378         312 :         return NIL;
    1379             : 
    1380             :     /* Build and return list of version names representing the update path */
    1381         506 :     result = NIL;
    1382        1826 :     for (evi = evi_target; evi != evi_start; evi = evi->previous)
    1383        1320 :         result = lcons(evi->name, result);
    1384             : 
    1385         506 :     return result;
    1386             : }
    1387             : 
    1388             : /*
    1389             :  * Given a target version that is not directly installable, find the
    1390             :  * best installation sequence starting from a directly-installable version.
    1391             :  *
    1392             :  * evi_list: previously-collected version update graph
    1393             :  * evi_target: member of that list that we want to reach
    1394             :  *
    1395             :  * Returns the best starting-point version, or NULL if there is none.
    1396             :  * On success, *best_path is set to the path from the start point.
    1397             :  *
    1398             :  * If there's more than one possible start point, prefer shorter update paths,
    1399             :  * and break any ties arbitrarily on the basis of strcmp'ing the starting
    1400             :  * versions' names.
    1401             :  */
    1402             : static ExtensionVersionInfo *
    1403         792 : find_install_path(List *evi_list, ExtensionVersionInfo *evi_target,
    1404             :                   List **best_path)
    1405             : {
    1406         792 :     ExtensionVersionInfo *evi_start = NULL;
    1407             :     ListCell   *lc;
    1408             : 
    1409         792 :     *best_path = NIL;
    1410             : 
    1411             :     /*
    1412             :      * We don't expect to be called for an installable target, but if we are,
    1413             :      * the answer is easy: just start from there, with an empty update path.
    1414             :      */
    1415         792 :     if (evi_target->installable)
    1416           0 :         return evi_target;
    1417             : 
    1418             :     /* Consider all installable versions as start points */
    1419        6108 :     foreach(lc, evi_list)
    1420             :     {
    1421        5316 :         ExtensionVersionInfo *evi1 = (ExtensionVersionInfo *) lfirst(lc);
    1422             :         List       *path;
    1423             : 
    1424        5316 :         if (!evi1->installable)
    1425        4524 :             continue;
    1426             : 
    1427             :         /*
    1428             :          * Find shortest path from evi1 to evi_target; but no need to consider
    1429             :          * paths going through other installable versions.
    1430             :          */
    1431         792 :         path = find_update_path(evi_list, evi1, evi_target, true, true);
    1432         792 :         if (path == NIL)
    1433         312 :             continue;
    1434             : 
    1435             :         /* Remember best path */
    1436         480 :         if (evi_start == NULL ||
    1437           0 :             list_length(path) < list_length(*best_path) ||
    1438           0 :             (list_length(path) == list_length(*best_path) &&
    1439           0 :              strcmp(evi_start->name, evi1->name) < 0))
    1440             :         {
    1441         480 :             evi_start = evi1;
    1442         480 :             *best_path = path;
    1443             :         }
    1444             :     }
    1445             : 
    1446         792 :     return evi_start;
    1447             : }
    1448             : 
    1449             : /*
    1450             :  * CREATE EXTENSION worker
    1451             :  *
    1452             :  * When CASCADE is specified, CreateExtensionInternal() recurses if required
    1453             :  * extensions need to be installed.  To sanely handle cyclic dependencies,
    1454             :  * the "parents" list contains a list of names of extensions already being
    1455             :  * installed, allowing us to error out if we recurse to one of those.
    1456             :  */
    1457             : static ObjectAddress
    1458         442 : CreateExtensionInternal(char *extensionName,
    1459             :                         char *schemaName,
    1460             :                         const char *versionName,
    1461             :                         bool cascade,
    1462             :                         List *parents,
    1463             :                         bool is_create)
    1464             : {
    1465         442 :     char       *origSchemaName = schemaName;
    1466         442 :     Oid         schemaOid = InvalidOid;
    1467         442 :     Oid         extowner = GetUserId();
    1468             :     ExtensionControlFile *pcontrol;
    1469             :     ExtensionControlFile *control;
    1470             :     char       *filename;
    1471             :     struct stat fst;
    1472             :     List       *updateVersions;
    1473             :     List       *requiredExtensions;
    1474             :     List       *requiredSchemas;
    1475             :     Oid         extensionOid;
    1476             :     ObjectAddress address;
    1477             :     ListCell   *lc;
    1478             : 
    1479             :     /*
    1480             :      * Read the primary control file.  Note we assume that it does not contain
    1481             :      * any non-ASCII data, so there is no need to worry about encoding at this
    1482             :      * point.
    1483             :      */
    1484         442 :     pcontrol = read_extension_control_file(extensionName);
    1485             : 
    1486             :     /*
    1487             :      * Determine the version to install
    1488             :      */
    1489         442 :     if (versionName == NULL)
    1490             :     {
    1491         432 :         if (pcontrol->default_version)
    1492         432 :             versionName = pcontrol->default_version;
    1493             :         else
    1494           0 :             ereport(ERROR,
    1495             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1496             :                      errmsg("version to install must be specified")));
    1497             :     }
    1498         442 :     check_valid_version_name(versionName);
    1499             : 
    1500             :     /*
    1501             :      * Figure out which script(s) we need to run to install the desired
    1502             :      * version of the extension.  If we do not have a script that directly
    1503             :      * does what is needed, we try to find a sequence of update scripts that
    1504             :      * will get us there.
    1505             :      */
    1506         442 :     filename = get_extension_script_filename(pcontrol, NULL, versionName);
    1507         442 :     if (stat(filename, &fst) == 0)
    1508             :     {
    1509             :         /* Easy, no extra scripts */
    1510         328 :         updateVersions = NIL;
    1511             :     }
    1512             :     else
    1513             :     {
    1514             :         /* Look for best way to install this version */
    1515             :         List       *evi_list;
    1516             :         ExtensionVersionInfo *evi_start;
    1517             :         ExtensionVersionInfo *evi_target;
    1518             : 
    1519             :         /* Extract the version update graph from the script directory */
    1520         114 :         evi_list = get_ext_ver_list(pcontrol);
    1521             : 
    1522             :         /* Identify the target version */
    1523         114 :         evi_target = get_ext_ver_info(versionName, &evi_list);
    1524             : 
    1525             :         /* Identify best path to reach target */
    1526         114 :         evi_start = find_install_path(evi_list, evi_target,
    1527             :                                       &updateVersions);
    1528             : 
    1529             :         /* Fail if no path ... */
    1530         114 :         if (evi_start == NULL)
    1531           0 :             ereport(ERROR,
    1532             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1533             :                      errmsg("extension \"%s\" has no installation script nor update path for version \"%s\"",
    1534             :                             pcontrol->name, versionName)));
    1535             : 
    1536             :         /* Otherwise, install best starting point and then upgrade */
    1537         114 :         versionName = evi_start->name;
    1538             :     }
    1539             : 
    1540             :     /*
    1541             :      * Fetch control parameters for installation target version
    1542             :      */
    1543         442 :     control = read_extension_aux_control_file(pcontrol, versionName);
    1544             : 
    1545             :     /*
    1546             :      * Determine the target schema to install the extension into
    1547             :      */
    1548         442 :     if (schemaName)
    1549             :     {
    1550             :         /* If the user is giving us the schema name, it must exist already. */
    1551          54 :         schemaOid = get_namespace_oid(schemaName, false);
    1552             :     }
    1553             : 
    1554         438 :     if (control->schema != NULL)
    1555             :     {
    1556             :         /*
    1557             :          * The extension is not relocatable and the author gave us a schema
    1558             :          * for it.
    1559             :          *
    1560             :          * Unless CASCADE parameter was given, it's an error to give a schema
    1561             :          * different from control->schema if control->schema is specified.
    1562             :          */
    1563         130 :         if (schemaName && strcmp(control->schema, schemaName) != 0 &&
    1564           4 :             !cascade)
    1565           2 :             ereport(ERROR,
    1566             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1567             :                      errmsg("extension \"%s\" must be installed in schema \"%s\"",
    1568             :                             control->name,
    1569             :                             control->schema)));
    1570             : 
    1571             :         /* Always use the schema from control file for current extension. */
    1572         128 :         schemaName = control->schema;
    1573             : 
    1574             :         /* Find or create the schema in case it does not exist. */
    1575         128 :         schemaOid = get_namespace_oid(schemaName, true);
    1576             : 
    1577         128 :         if (!OidIsValid(schemaOid))
    1578             :         {
    1579           6 :             CreateSchemaStmt *csstmt = makeNode(CreateSchemaStmt);
    1580             : 
    1581           6 :             csstmt->schemaname = schemaName;
    1582           6 :             csstmt->authrole = NULL; /* will be created by current user */
    1583           6 :             csstmt->schemaElts = NIL;
    1584           6 :             csstmt->if_not_exists = false;
    1585           6 :             CreateSchemaCommand(csstmt, "(generated CREATE SCHEMA command)",
    1586             :                                 -1, -1);
    1587             : 
    1588             :             /*
    1589             :              * CreateSchemaCommand includes CommandCounterIncrement, so new
    1590             :              * schema is now visible.
    1591             :              */
    1592           6 :             schemaOid = get_namespace_oid(schemaName, false);
    1593             :         }
    1594             :     }
    1595         308 :     else if (!OidIsValid(schemaOid))
    1596             :     {
    1597             :         /*
    1598             :          * Neither user nor author of the extension specified schema; use the
    1599             :          * current default creation namespace, which is the first explicit
    1600             :          * entry in the search_path.
    1601             :          */
    1602         262 :         List       *search_path = fetch_search_path(false);
    1603             : 
    1604         262 :         if (search_path == NIL) /* nothing valid in search_path? */
    1605           0 :             ereport(ERROR,
    1606             :                     (errcode(ERRCODE_UNDEFINED_SCHEMA),
    1607             :                      errmsg("no schema has been selected to create in")));
    1608         262 :         schemaOid = linitial_oid(search_path);
    1609         262 :         schemaName = get_namespace_name(schemaOid);
    1610         262 :         if (schemaName == NULL) /* recently-deleted namespace? */
    1611           0 :             ereport(ERROR,
    1612             :                     (errcode(ERRCODE_UNDEFINED_SCHEMA),
    1613             :                      errmsg("no schema has been selected to create in")));
    1614             : 
    1615         262 :         list_free(search_path);
    1616             :     }
    1617             : 
    1618             :     /*
    1619             :      * Make note if a temporary namespace has been accessed in this
    1620             :      * transaction.
    1621             :      */
    1622         436 :     if (isTempNamespace(schemaOid))
    1623           4 :         MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE;
    1624             : 
    1625             :     /*
    1626             :      * We don't check creation rights on the target namespace here.  If the
    1627             :      * extension script actually creates any objects there, it will fail if
    1628             :      * the user doesn't have such permissions.  But there are cases such as
    1629             :      * procedural languages where it's convenient to set schema = pg_catalog
    1630             :      * yet we don't want to restrict the command to users with ACL_CREATE for
    1631             :      * pg_catalog.
    1632             :      */
    1633             : 
    1634             :     /*
    1635             :      * Look up the prerequisite extensions, install them if necessary, and
    1636             :      * build lists of their OIDs and the OIDs of their target schemas.
    1637             :      */
    1638         436 :     requiredExtensions = NIL;
    1639         436 :     requiredSchemas = NIL;
    1640         490 :     foreach(lc, control->requires)
    1641             :     {
    1642          64 :         char       *curreq = (char *) lfirst(lc);
    1643             :         Oid         reqext;
    1644             :         Oid         reqschema;
    1645             : 
    1646          64 :         reqext = get_required_extension(curreq,
    1647             :                                         extensionName,
    1648             :                                         origSchemaName,
    1649             :                                         cascade,
    1650             :                                         parents,
    1651             :                                         is_create);
    1652          54 :         reqschema = get_extension_schema(reqext);
    1653          54 :         requiredExtensions = lappend_oid(requiredExtensions, reqext);
    1654          54 :         requiredSchemas = lappend_oid(requiredSchemas, reqschema);
    1655             :     }
    1656             : 
    1657             :     /*
    1658             :      * Insert new tuple into pg_extension, and create dependency entries.
    1659             :      */
    1660         426 :     address = InsertExtensionTuple(control->name, extowner,
    1661         426 :                                    schemaOid, control->relocatable,
    1662             :                                    versionName,
    1663             :                                    PointerGetDatum(NULL),
    1664             :                                    PointerGetDatum(NULL),
    1665             :                                    requiredExtensions);
    1666         426 :     extensionOid = address.objectId;
    1667             : 
    1668             :     /*
    1669             :      * Apply any control-file comment on extension
    1670             :      */
    1671         426 :     if (control->comment != NULL)
    1672         426 :         CreateComments(extensionOid, ExtensionRelationId, 0, control->comment);
    1673             : 
    1674             :     /*
    1675             :      * Execute the installation script file
    1676             :      */
    1677         426 :     execute_extension_script(extensionOid, control,
    1678             :                              NULL, versionName,
    1679             :                              requiredSchemas,
    1680             :                              schemaName, schemaOid);
    1681             : 
    1682             :     /*
    1683             :      * If additional update scripts have to be executed, apply the updates as
    1684             :      * though a series of ALTER EXTENSION UPDATE commands were given
    1685             :      */
    1686         394 :     ApplyExtensionUpdates(extensionOid, pcontrol,
    1687             :                           versionName, updateVersions,
    1688             :                           origSchemaName, cascade, is_create);
    1689             : 
    1690         394 :     return address;
    1691             : }
    1692             : 
    1693             : /*
    1694             :  * Get the OID of an extension listed in "requires", possibly creating it.
    1695             :  */
    1696             : static Oid
    1697          64 : get_required_extension(char *reqExtensionName,
    1698             :                        char *extensionName,
    1699             :                        char *origSchemaName,
    1700             :                        bool cascade,
    1701             :                        List *parents,
    1702             :                        bool is_create)
    1703             : {
    1704             :     Oid         reqExtensionOid;
    1705             : 
    1706          64 :     reqExtensionOid = get_extension_oid(reqExtensionName, true);
    1707          64 :     if (!OidIsValid(reqExtensionOid))
    1708             :     {
    1709          44 :         if (cascade)
    1710             :         {
    1711             :             /* Must install it. */
    1712             :             ObjectAddress addr;
    1713             :             List       *cascade_parents;
    1714             :             ListCell   *lc;
    1715             : 
    1716             :             /* Check extension name validity before trying to cascade. */
    1717          40 :             check_valid_extension_name(reqExtensionName);
    1718             : 
    1719             :             /* Check for cyclic dependency between extensions. */
    1720          44 :             foreach(lc, parents)
    1721             :             {
    1722           6 :                 char       *pname = (char *) lfirst(lc);
    1723             : 
    1724           6 :                 if (strcmp(pname, reqExtensionName) == 0)
    1725           2 :                     ereport(ERROR,
    1726             :                             (errcode(ERRCODE_INVALID_RECURSION),
    1727             :                              errmsg("cyclic dependency detected between extensions \"%s\" and \"%s\"",
    1728             :                                     reqExtensionName, extensionName)));
    1729             :             }
    1730             : 
    1731          38 :             ereport(NOTICE,
    1732             :                     (errmsg("installing required extension \"%s\"",
    1733             :                             reqExtensionName)));
    1734             : 
    1735             :             /* Add current extension to list of parents to pass down. */
    1736          38 :             cascade_parents = lappend(list_copy(parents), extensionName);
    1737             : 
    1738             :             /*
    1739             :              * Create the required extension.  We propagate the SCHEMA option
    1740             :              * if any, and CASCADE, but no other options.
    1741             :              */
    1742          38 :             addr = CreateExtensionInternal(reqExtensionName,
    1743             :                                            origSchemaName,
    1744             :                                            NULL,
    1745             :                                            cascade,
    1746             :                                            cascade_parents,
    1747             :                                            is_create);
    1748             : 
    1749             :             /* Get its newly-assigned OID. */
    1750          34 :             reqExtensionOid = addr.objectId;
    1751             :         }
    1752             :         else
    1753           4 :             ereport(ERROR,
    1754             :                     (errcode(ERRCODE_UNDEFINED_OBJECT),
    1755             :                      errmsg("required extension \"%s\" is not installed",
    1756             :                             reqExtensionName),
    1757             :                      is_create ?
    1758             :                      errhint("Use CREATE EXTENSION ... CASCADE to install required extensions too.") : 0));
    1759             :     }
    1760             : 
    1761          54 :     return reqExtensionOid;
    1762             : }
    1763             : 
    1764             : /*
    1765             :  * CREATE EXTENSION
    1766             :  */
    1767             : ObjectAddress
    1768         406 : CreateExtension(ParseState *pstate, CreateExtensionStmt *stmt)
    1769             : {
    1770         406 :     DefElem    *d_schema = NULL;
    1771         406 :     DefElem    *d_new_version = NULL;
    1772         406 :     DefElem    *d_cascade = NULL;
    1773         406 :     char       *schemaName = NULL;
    1774         406 :     char       *versionName = NULL;
    1775         406 :     bool        cascade = false;
    1776             :     ListCell   *lc;
    1777             : 
    1778             :     /* Check extension name validity before any filesystem access */
    1779         406 :     check_valid_extension_name(stmt->extname);
    1780             : 
    1781             :     /*
    1782             :      * Check for duplicate extension name.  The unique index on
    1783             :      * pg_extension.extname would catch this anyway, and serves as a backstop
    1784             :      * in case of race conditions; but this is a friendlier error message, and
    1785             :      * besides we need a check to support IF NOT EXISTS.
    1786             :      */
    1787         406 :     if (get_extension_oid(stmt->extname, true) != InvalidOid)
    1788             :     {
    1789           2 :         if (stmt->if_not_exists)
    1790             :         {
    1791           2 :             ereport(NOTICE,
    1792             :                     (errcode(ERRCODE_DUPLICATE_OBJECT),
    1793             :                      errmsg("extension \"%s\" already exists, skipping",
    1794             :                             stmt->extname)));
    1795           2 :             return InvalidObjectAddress;
    1796             :         }
    1797             :         else
    1798           0 :             ereport(ERROR,
    1799             :                     (errcode(ERRCODE_DUPLICATE_OBJECT),
    1800             :                      errmsg("extension \"%s\" already exists",
    1801             :                             stmt->extname)));
    1802             :     }
    1803             : 
    1804             :     /*
    1805             :      * We use global variables to track the extension being created, so we can
    1806             :      * create only one extension at the same time.
    1807             :      */
    1808         404 :     if (creating_extension)
    1809           0 :         ereport(ERROR,
    1810             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1811             :                  errmsg("nested CREATE EXTENSION is not supported")));
    1812             : 
    1813             :     /* Deconstruct the statement option list */
    1814         498 :     foreach(lc, stmt->options)
    1815             :     {
    1816          94 :         DefElem    *defel = (DefElem *) lfirst(lc);
    1817             : 
    1818          94 :         if (strcmp(defel->defname, "schema") == 0)
    1819             :         {
    1820          44 :             if (d_schema)
    1821           0 :                 errorConflictingDefElem(defel, pstate);
    1822          44 :             d_schema = defel;
    1823          44 :             schemaName = defGetString(d_schema);
    1824             :         }
    1825          50 :         else if (strcmp(defel->defname, "new_version") == 0)
    1826             :         {
    1827          10 :             if (d_new_version)
    1828           0 :                 errorConflictingDefElem(defel, pstate);
    1829          10 :             d_new_version = defel;
    1830          10 :             versionName = defGetString(d_new_version);
    1831             :         }
    1832          40 :         else if (strcmp(defel->defname, "cascade") == 0)
    1833             :         {
    1834          40 :             if (d_cascade)
    1835           0 :                 errorConflictingDefElem(defel, pstate);
    1836          40 :             d_cascade = defel;
    1837          40 :             cascade = defGetBoolean(d_cascade);
    1838             :         }
    1839             :         else
    1840           0 :             elog(ERROR, "unrecognized option: %s", defel->defname);
    1841             :     }
    1842             : 
    1843             :     /* Call CreateExtensionInternal to do the real work. */
    1844         404 :     return CreateExtensionInternal(stmt->extname,
    1845             :                                    schemaName,
    1846             :                                    versionName,
    1847             :                                    cascade,
    1848             :                                    NIL,
    1849             :                                    true);
    1850             : }
    1851             : 
    1852             : /*
    1853             :  * InsertExtensionTuple
    1854             :  *
    1855             :  * Insert the new pg_extension row, and create extension's dependency entries.
    1856             :  * Return the OID assigned to the new row.
    1857             :  *
    1858             :  * This is exported for the benefit of pg_upgrade, which has to create a
    1859             :  * pg_extension entry (and the extension-level dependencies) without
    1860             :  * actually running the extension's script.
    1861             :  *
    1862             :  * extConfig and extCondition should be arrays or PointerGetDatum(NULL).
    1863             :  * We declare them as plain Datum to avoid needing array.h in extension.h.
    1864             :  */
    1865             : ObjectAddress
    1866         426 : InsertExtensionTuple(const char *extName, Oid extOwner,
    1867             :                      Oid schemaOid, bool relocatable, const char *extVersion,
    1868             :                      Datum extConfig, Datum extCondition,
    1869             :                      List *requiredExtensions)
    1870             : {
    1871             :     Oid         extensionOid;
    1872             :     Relation    rel;
    1873             :     Datum       values[Natts_pg_extension];
    1874             :     bool        nulls[Natts_pg_extension];
    1875             :     HeapTuple   tuple;
    1876             :     ObjectAddress myself;
    1877             :     ObjectAddress nsp;
    1878             :     ObjectAddresses *refobjs;
    1879             :     ListCell   *lc;
    1880             : 
    1881             :     /*
    1882             :      * Build and insert the pg_extension tuple
    1883             :      */
    1884         426 :     rel = table_open(ExtensionRelationId, RowExclusiveLock);
    1885             : 
    1886         426 :     memset(values, 0, sizeof(values));
    1887         426 :     memset(nulls, 0, sizeof(nulls));
    1888             : 
    1889         426 :     extensionOid = GetNewOidWithIndex(rel, ExtensionOidIndexId,
    1890             :                                       Anum_pg_extension_oid);
    1891         426 :     values[Anum_pg_extension_oid - 1] = ObjectIdGetDatum(extensionOid);
    1892         426 :     values[Anum_pg_extension_extname - 1] =
    1893         426 :         DirectFunctionCall1(namein, CStringGetDatum(extName));
    1894         426 :     values[Anum_pg_extension_extowner - 1] = ObjectIdGetDatum(extOwner);
    1895         426 :     values[Anum_pg_extension_extnamespace - 1] = ObjectIdGetDatum(schemaOid);
    1896         426 :     values[Anum_pg_extension_extrelocatable - 1] = BoolGetDatum(relocatable);
    1897         426 :     values[Anum_pg_extension_extversion - 1] = CStringGetTextDatum(extVersion);
    1898             : 
    1899         426 :     if (extConfig == PointerGetDatum(NULL))
    1900         426 :         nulls[Anum_pg_extension_extconfig - 1] = true;
    1901             :     else
    1902           0 :         values[Anum_pg_extension_extconfig - 1] = extConfig;
    1903             : 
    1904         426 :     if (extCondition == PointerGetDatum(NULL))
    1905         426 :         nulls[Anum_pg_extension_extcondition - 1] = true;
    1906             :     else
    1907           0 :         values[Anum_pg_extension_extcondition - 1] = extCondition;
    1908             : 
    1909         426 :     tuple = heap_form_tuple(rel->rd_att, values, nulls);
    1910             : 
    1911         426 :     CatalogTupleInsert(rel, tuple);
    1912             : 
    1913         426 :     heap_freetuple(tuple);
    1914         426 :     table_close(rel, RowExclusiveLock);
    1915             : 
    1916             :     /*
    1917             :      * Record dependencies on owner, schema, and prerequisite extensions
    1918             :      */
    1919         426 :     recordDependencyOnOwner(ExtensionRelationId, extensionOid, extOwner);
    1920             : 
    1921         426 :     refobjs = new_object_addresses();
    1922             : 
    1923         426 :     ObjectAddressSet(myself, ExtensionRelationId, extensionOid);
    1924             : 
    1925         426 :     ObjectAddressSet(nsp, NamespaceRelationId, schemaOid);
    1926         426 :     add_exact_object_address(&nsp, refobjs);
    1927             : 
    1928         478 :     foreach(lc, requiredExtensions)
    1929             :     {
    1930          52 :         Oid         reqext = lfirst_oid(lc);
    1931             :         ObjectAddress otherext;
    1932             : 
    1933          52 :         ObjectAddressSet(otherext, ExtensionRelationId, reqext);
    1934          52 :         add_exact_object_address(&otherext, refobjs);
    1935             :     }
    1936             : 
    1937             :     /* Record all of them (this includes duplicate elimination) */
    1938         426 :     record_object_address_dependencies(&myself, refobjs, DEPENDENCY_NORMAL);
    1939         426 :     free_object_addresses(refobjs);
    1940             : 
    1941             :     /* Post creation hook for new extension */
    1942         426 :     InvokeObjectPostCreateHook(ExtensionRelationId, extensionOid, 0);
    1943             : 
    1944         426 :     return myself;
    1945             : }
    1946             : 
    1947             : /*
    1948             :  * Guts of extension deletion.
    1949             :  *
    1950             :  * All we need do here is remove the pg_extension tuple itself.  Everything
    1951             :  * else is taken care of by the dependency infrastructure.
    1952             :  */
    1953             : void
    1954         106 : RemoveExtensionById(Oid extId)
    1955             : {
    1956             :     Relation    rel;
    1957             :     SysScanDesc scandesc;
    1958             :     HeapTuple   tuple;
    1959             :     ScanKeyData entry[1];
    1960             : 
    1961             :     /*
    1962             :      * Disallow deletion of any extension that's currently open for insertion;
    1963             :      * else subsequent executions of recordDependencyOnCurrentExtension()
    1964             :      * could create dangling pg_depend records that refer to a no-longer-valid
    1965             :      * pg_extension OID.  This is needed not so much because we think people
    1966             :      * might write "DROP EXTENSION foo" in foo's own script files, as because
    1967             :      * errors in dependency management in extension script files could give
    1968             :      * rise to cases where an extension is dropped as a result of recursing
    1969             :      * from some contained object.  Because of that, we must test for the case
    1970             :      * here, not at some higher level of the DROP EXTENSION command.
    1971             :      */
    1972         106 :     if (extId == CurrentExtensionObject)
    1973           0 :         ereport(ERROR,
    1974             :                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    1975             :                  errmsg("cannot drop extension \"%s\" because it is being modified",
    1976             :                         get_extension_name(extId))));
    1977             : 
    1978         106 :     rel = table_open(ExtensionRelationId, RowExclusiveLock);
    1979             : 
    1980         106 :     ScanKeyInit(&entry[0],
    1981             :                 Anum_pg_extension_oid,
    1982             :                 BTEqualStrategyNumber, F_OIDEQ,
    1983             :                 ObjectIdGetDatum(extId));
    1984         106 :     scandesc = systable_beginscan(rel, ExtensionOidIndexId, true,
    1985             :                                   NULL, 1, entry);
    1986             : 
    1987         106 :     tuple = systable_getnext(scandesc);
    1988             : 
    1989             :     /* We assume that there can be at most one matching tuple */
    1990         106 :     if (HeapTupleIsValid(tuple))
    1991         106 :         CatalogTupleDelete(rel, &tuple->t_self);
    1992             : 
    1993         106 :     systable_endscan(scandesc);
    1994             : 
    1995         106 :     table_close(rel, RowExclusiveLock);
    1996         106 : }
    1997             : 
    1998             : /*
    1999             :  * This function lists the available extensions (one row per primary control
    2000             :  * file in the control directory).  We parse each control file and report the
    2001             :  * interesting fields.
    2002             :  *
    2003             :  * The system view pg_available_extensions provides a user interface to this
    2004             :  * SRF, adding information about whether the extensions are installed in the
    2005             :  * current DB.
    2006             :  */
    2007             : Datum
    2008          26 : pg_available_extensions(PG_FUNCTION_ARGS)
    2009             : {
    2010          26 :     ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    2011             :     char       *location;
    2012             :     DIR        *dir;
    2013             :     struct dirent *de;
    2014             : 
    2015             :     /* Build tuplestore to hold the result rows */
    2016          26 :     InitMaterializedSRF(fcinfo, 0);
    2017             : 
    2018          26 :     location = get_extension_control_directory();
    2019          26 :     dir = AllocateDir(location);
    2020             : 
    2021             :     /*
    2022             :      * If the control directory doesn't exist, we want to silently return an
    2023             :      * empty set.  Any other error will be reported by ReadDir.
    2024             :      */
    2025          26 :     if (dir == NULL && errno == ENOENT)
    2026             :     {
    2027             :         /* do nothing */
    2028             :     }
    2029             :     else
    2030             :     {
    2031        8268 :         while ((de = ReadDir(dir, location)) != NULL)
    2032             :         {
    2033             :             ExtensionControlFile *control;
    2034             :             char       *extname;
    2035             :             Datum       values[3];
    2036             :             bool        nulls[3];
    2037             : 
    2038        8242 :             if (!is_extension_control_filename(de->d_name))
    2039        5616 :                 continue;
    2040             : 
    2041             :             /* extract extension name from 'name.control' filename */
    2042        2626 :             extname = pstrdup(de->d_name);
    2043        2626 :             *strrchr(extname, '.') = '\0';
    2044             : 
    2045             :             /* ignore it if it's an auxiliary control file */
    2046        2626 :             if (strstr(extname, "--"))
    2047           0 :                 continue;
    2048             : 
    2049        2626 :             control = read_extension_control_file(extname);
    2050             : 
    2051        2626 :             memset(values, 0, sizeof(values));
    2052        2626 :             memset(nulls, 0, sizeof(nulls));
    2053             : 
    2054             :             /* name */
    2055        2626 :             values[0] = DirectFunctionCall1(namein,
    2056             :                                             CStringGetDatum(control->name));
    2057             :             /* default_version */
    2058        2626 :             if (control->default_version == NULL)
    2059           0 :                 nulls[1] = true;
    2060             :             else
    2061        2626 :                 values[1] = CStringGetTextDatum(control->default_version);
    2062             :             /* comment */
    2063        2626 :             if (control->comment == NULL)
    2064           0 :                 nulls[2] = true;
    2065             :             else
    2066        2626 :                 values[2] = CStringGetTextDatum(control->comment);
    2067             : 
    2068        2626 :             tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
    2069             :                                  values, nulls);
    2070             :         }
    2071             : 
    2072          26 :         FreeDir(dir);
    2073             :     }
    2074             : 
    2075          26 :     return (Datum) 0;
    2076             : }
    2077             : 
    2078             : /*
    2079             :  * This function lists the available extension versions (one row per
    2080             :  * extension installation script).  For each version, we parse the related
    2081             :  * control file(s) and report the interesting fields.
    2082             :  *
    2083             :  * The system view pg_available_extension_versions provides a user interface
    2084             :  * to this SRF, adding information about which versions are installed in the
    2085             :  * current DB.
    2086             :  */
    2087             : Datum
    2088           6 : pg_available_extension_versions(PG_FUNCTION_ARGS)
    2089             : {
    2090           6 :     ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    2091             :     char       *location;
    2092             :     DIR        *dir;
    2093             :     struct dirent *de;
    2094             : 
    2095             :     /* Build tuplestore to hold the result rows */
    2096           6 :     InitMaterializedSRF(fcinfo, 0);
    2097             : 
    2098           6 :     location = get_extension_control_directory();
    2099           6 :     dir = AllocateDir(location);
    2100             : 
    2101             :     /*
    2102             :      * If the control directory doesn't exist, we want to silently return an
    2103             :      * empty set.  Any other error will be reported by ReadDir.
    2104             :      */
    2105           6 :     if (dir == NULL && errno == ENOENT)
    2106             :     {
    2107             :         /* do nothing */
    2108             :     }
    2109             :     else
    2110             :     {
    2111        1908 :         while ((de = ReadDir(dir, location)) != NULL)
    2112             :         {
    2113             :             ExtensionControlFile *control;
    2114             :             char       *extname;
    2115             : 
    2116        1902 :             if (!is_extension_control_filename(de->d_name))
    2117        1296 :                 continue;
    2118             : 
    2119             :             /* extract extension name from 'name.control' filename */
    2120         606 :             extname = pstrdup(de->d_name);
    2121         606 :             *strrchr(extname, '.') = '\0';
    2122             : 
    2123             :             /* ignore it if it's an auxiliary control file */
    2124         606 :             if (strstr(extname, "--"))
    2125           0 :                 continue;
    2126             : 
    2127             :             /* read the control file */
    2128         606 :             control = read_extension_control_file(extname);
    2129             : 
    2130             :             /* scan extension's script directory for install scripts */
    2131         606 :             get_available_versions_for_extension(control, rsinfo->setResult,
    2132             :                                                  rsinfo->setDesc);
    2133             :         }
    2134             : 
    2135           6 :         FreeDir(dir);
    2136             :     }
    2137             : 
    2138           6 :     return (Datum) 0;
    2139             : }
    2140             : 
    2141             : /*
    2142             :  * Inner loop for pg_available_extension_versions:
    2143             :  *      read versions of one extension, add rows to tupstore
    2144             :  */
    2145             : static void
    2146         606 : get_available_versions_for_extension(ExtensionControlFile *pcontrol,
    2147             :                                      Tuplestorestate *tupstore,
    2148             :                                      TupleDesc tupdesc)
    2149             : {
    2150             :     List       *evi_list;
    2151             :     ListCell   *lc;
    2152             : 
    2153             :     /* Extract the version update graph from the script directory */
    2154         606 :     evi_list = get_ext_ver_list(pcontrol);
    2155             : 
    2156             :     /* For each installable version ... */
    2157        1890 :     foreach(lc, evi_list)
    2158             :     {
    2159        1284 :         ExtensionVersionInfo *evi = (ExtensionVersionInfo *) lfirst(lc);
    2160             :         ExtensionControlFile *control;
    2161             :         Datum       values[8];
    2162             :         bool        nulls[8];
    2163             :         ListCell   *lc2;
    2164             : 
    2165        1284 :         if (!evi->installable)
    2166         678 :             continue;
    2167             : 
    2168             :         /*
    2169             :          * Fetch parameters for specific version (pcontrol is not changed)
    2170             :          */
    2171         606 :         control = read_extension_aux_control_file(pcontrol, evi->name);
    2172             : 
    2173         606 :         memset(values, 0, sizeof(values));
    2174         606 :         memset(nulls, 0, sizeof(nulls));
    2175             : 
    2176             :         /* name */
    2177         606 :         values[0] = DirectFunctionCall1(namein,
    2178             :                                         CStringGetDatum(control->name));
    2179             :         /* version */
    2180         606 :         values[1] = CStringGetTextDatum(evi->name);
    2181             :         /* superuser */
    2182         606 :         values[2] = BoolGetDatum(control->superuser);
    2183             :         /* trusted */
    2184         606 :         values[3] = BoolGetDatum(control->trusted);
    2185             :         /* relocatable */
    2186         606 :         values[4] = BoolGetDatum(control->relocatable);
    2187             :         /* schema */
    2188         606 :         if (control->schema == NULL)
    2189         540 :             nulls[5] = true;
    2190             :         else
    2191          66 :             values[5] = DirectFunctionCall1(namein,
    2192             :                                             CStringGetDatum(control->schema));
    2193             :         /* requires */
    2194         606 :         if (control->requires == NIL)
    2195         504 :             nulls[6] = true;
    2196             :         else
    2197         102 :             values[6] = convert_requires_to_datum(control->requires);
    2198             :         /* comment */
    2199         606 :         if (control->comment == NULL)
    2200           0 :             nulls[7] = true;
    2201             :         else
    2202         606 :             values[7] = CStringGetTextDatum(control->comment);
    2203             : 
    2204         606 :         tuplestore_putvalues(tupstore, tupdesc, values, nulls);
    2205             : 
    2206             :         /*
    2207             :          * Find all non-directly-installable versions that would be installed
    2208             :          * starting from this version, and report them, inheriting the
    2209             :          * parameters that aren't changed in updates from this version.
    2210             :          */
    2211        1890 :         foreach(lc2, evi_list)
    2212             :         {
    2213        1284 :             ExtensionVersionInfo *evi2 = (ExtensionVersionInfo *) lfirst(lc2);
    2214             :             List       *best_path;
    2215             : 
    2216        1284 :             if (evi2->installable)
    2217         606 :                 continue;
    2218         678 :             if (find_install_path(evi_list, evi2, &best_path) == evi)
    2219             :             {
    2220             :                 /*
    2221             :                  * Fetch parameters for this version (pcontrol is not changed)
    2222             :                  */
    2223         366 :                 control = read_extension_aux_control_file(pcontrol, evi2->name);
    2224             : 
    2225             :                 /* name stays the same */
    2226             :                 /* version */
    2227         366 :                 values[1] = CStringGetTextDatum(evi2->name);
    2228             :                 /* superuser */
    2229         366 :                 values[2] = BoolGetDatum(control->superuser);
    2230             :                 /* trusted */
    2231         366 :                 values[3] = BoolGetDatum(control->trusted);
    2232             :                 /* relocatable */
    2233         366 :                 values[4] = BoolGetDatum(control->relocatable);
    2234             :                 /* schema stays the same */
    2235             :                 /* requires */
    2236         366 :                 if (control->requires == NIL)
    2237         366 :                     nulls[6] = true;
    2238             :                 else
    2239             :                 {
    2240           0 :                     values[6] = convert_requires_to_datum(control->requires);
    2241           0 :                     nulls[6] = false;
    2242             :                 }
    2243             :                 /* comment stays the same */
    2244             : 
    2245         366 :                 tuplestore_putvalues(tupstore, tupdesc, values, nulls);
    2246             :             }
    2247             :         }
    2248             :     }
    2249         606 : }
    2250             : 
    2251             : /*
    2252             :  * Test whether the given extension exists (not whether it's installed)
    2253             :  *
    2254             :  * This checks for the existence of a matching control file in the extension
    2255             :  * directory.  That's not a bulletproof check, since the file might be
    2256             :  * invalid, but this is only used for hints so it doesn't have to be 100%
    2257             :  * right.
    2258             :  */
    2259             : bool
    2260           0 : extension_file_exists(const char *extensionName)
    2261             : {
    2262           0 :     bool        result = false;
    2263             :     char       *location;
    2264             :     DIR        *dir;
    2265             :     struct dirent *de;
    2266             : 
    2267           0 :     location = get_extension_control_directory();
    2268           0 :     dir = AllocateDir(location);
    2269             : 
    2270             :     /*
    2271             :      * If the control directory doesn't exist, we want to silently return
    2272             :      * false.  Any other error will be reported by ReadDir.
    2273             :      */
    2274           0 :     if (dir == NULL && errno == ENOENT)
    2275             :     {
    2276             :         /* do nothing */
    2277             :     }
    2278             :     else
    2279             :     {
    2280           0 :         while ((de = ReadDir(dir, location)) != NULL)
    2281             :         {
    2282             :             char       *extname;
    2283             : 
    2284           0 :             if (!is_extension_control_filename(de->d_name))
    2285           0 :                 continue;
    2286             : 
    2287             :             /* extract extension name from 'name.control' filename */
    2288           0 :             extname = pstrdup(de->d_name);
    2289           0 :             *strrchr(extname, '.') = '\0';
    2290             : 
    2291             :             /* ignore it if it's an auxiliary control file */
    2292           0 :             if (strstr(extname, "--"))
    2293           0 :                 continue;
    2294             : 
    2295             :             /* done if it matches request */
    2296           0 :             if (strcmp(extname, extensionName) == 0)
    2297             :             {
    2298           0 :                 result = true;
    2299           0 :                 break;
    2300             :             }
    2301             :         }
    2302             : 
    2303           0 :         FreeDir(dir);
    2304             :     }
    2305             : 
    2306           0 :     return result;
    2307             : }
    2308             : 
    2309             : /*
    2310             :  * Convert a list of extension names to a name[] Datum
    2311             :  */
    2312             : static Datum
    2313         102 : convert_requires_to_datum(List *requires)
    2314             : {
    2315             :     Datum      *datums;
    2316             :     int         ndatums;
    2317             :     ArrayType  *a;
    2318             :     ListCell   *lc;
    2319             : 
    2320         102 :     ndatums = list_length(requires);
    2321         102 :     datums = (Datum *) palloc(ndatums * sizeof(Datum));
    2322         102 :     ndatums = 0;
    2323         246 :     foreach(lc, requires)
    2324             :     {
    2325         144 :         char       *curreq = (char *) lfirst(lc);
    2326             : 
    2327         144 :         datums[ndatums++] =
    2328         144 :             DirectFunctionCall1(namein, CStringGetDatum(curreq));
    2329             :     }
    2330         102 :     a = construct_array_builtin(datums, ndatums, NAMEOID);
    2331         102 :     return PointerGetDatum(a);
    2332             : }
    2333             : 
    2334             : /*
    2335             :  * This function reports the version update paths that exist for the
    2336             :  * specified extension.
    2337             :  */
    2338             : Datum
    2339           0 : pg_extension_update_paths(PG_FUNCTION_ARGS)
    2340             : {
    2341           0 :     Name        extname = PG_GETARG_NAME(0);
    2342           0 :     ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    2343             :     List       *evi_list;
    2344             :     ExtensionControlFile *control;
    2345             :     ListCell   *lc1;
    2346             : 
    2347             :     /* Check extension name validity before any filesystem access */
    2348           0 :     check_valid_extension_name(NameStr(*extname));
    2349             : 
    2350             :     /* Build tuplestore to hold the result rows */
    2351           0 :     InitMaterializedSRF(fcinfo, 0);
    2352             : 
    2353             :     /* Read the extension's control file */
    2354           0 :     control = read_extension_control_file(NameStr(*extname));
    2355             : 
    2356             :     /* Extract the version update graph from the script directory */
    2357           0 :     evi_list = get_ext_ver_list(control);
    2358             : 
    2359             :     /* Iterate over all pairs of versions */
    2360           0 :     foreach(lc1, evi_list)
    2361             :     {
    2362           0 :         ExtensionVersionInfo *evi1 = (ExtensionVersionInfo *) lfirst(lc1);
    2363             :         ListCell   *lc2;
    2364             : 
    2365           0 :         foreach(lc2, evi_list)
    2366             :         {
    2367           0 :             ExtensionVersionInfo *evi2 = (ExtensionVersionInfo *) lfirst(lc2);
    2368             :             List       *path;
    2369             :             Datum       values[3];
    2370             :             bool        nulls[3];
    2371             : 
    2372           0 :             if (evi1 == evi2)
    2373           0 :                 continue;
    2374             : 
    2375             :             /* Find shortest path from evi1 to evi2 */
    2376           0 :             path = find_update_path(evi_list, evi1, evi2, false, true);
    2377             : 
    2378             :             /* Emit result row */
    2379           0 :             memset(values, 0, sizeof(values));
    2380           0 :             memset(nulls, 0, sizeof(nulls));
    2381             : 
    2382             :             /* source */
    2383           0 :             values[0] = CStringGetTextDatum(evi1->name);
    2384             :             /* target */
    2385           0 :             values[1] = CStringGetTextDatum(evi2->name);
    2386             :             /* path */
    2387           0 :             if (path == NIL)
    2388           0 :                 nulls[2] = true;
    2389             :             else
    2390             :             {
    2391             :                 StringInfoData pathbuf;
    2392             :                 ListCell   *lcv;
    2393             : 
    2394           0 :                 initStringInfo(&pathbuf);
    2395             :                 /* The path doesn't include start vertex, but show it */
    2396           0 :                 appendStringInfoString(&pathbuf, evi1->name);
    2397           0 :                 foreach(lcv, path)
    2398             :                 {
    2399           0 :                     char       *versionName = (char *) lfirst(lcv);
    2400             : 
    2401           0 :                     appendStringInfoString(&pathbuf, "--");
    2402           0 :                     appendStringInfoString(&pathbuf, versionName);
    2403             :                 }
    2404           0 :                 values[2] = CStringGetTextDatum(pathbuf.data);
    2405           0 :                 pfree(pathbuf.data);
    2406             :             }
    2407             : 
    2408           0 :             tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
    2409             :                                  values, nulls);
    2410             :         }
    2411             :     }
    2412             : 
    2413           0 :     return (Datum) 0;
    2414             : }
    2415             : 
    2416             : /*
    2417             :  * pg_extension_config_dump
    2418             :  *
    2419             :  * Record information about a configuration table that belongs to an
    2420             :  * extension being created, but whose contents should be dumped in whole
    2421             :  * or in part during pg_dump.
    2422             :  */
    2423             : Datum
    2424           8 : pg_extension_config_dump(PG_FUNCTION_ARGS)
    2425             : {
    2426           8 :     Oid         tableoid = PG_GETARG_OID(0);
    2427           8 :     text       *wherecond = PG_GETARG_TEXT_PP(1);
    2428             :     char       *tablename;
    2429             :     Relation    extRel;
    2430             :     ScanKeyData key[1];
    2431             :     SysScanDesc extScan;
    2432             :     HeapTuple   extTup;
    2433             :     Datum       arrayDatum;
    2434             :     Datum       elementDatum;
    2435             :     int         arrayLength;
    2436             :     int         arrayIndex;
    2437             :     bool        isnull;
    2438             :     Datum       repl_val[Natts_pg_extension];
    2439             :     bool        repl_null[Natts_pg_extension];
    2440             :     bool        repl_repl[Natts_pg_extension];
    2441             :     ArrayType  *a;
    2442             : 
    2443             :     /*
    2444             :      * We only allow this to be called from an extension's SQL script. We
    2445             :      * shouldn't need any permissions check beyond that.
    2446             :      */
    2447           8 :     if (!creating_extension)
    2448           0 :         ereport(ERROR,
    2449             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    2450             :                  errmsg("%s can only be called from an SQL script executed by CREATE EXTENSION",
    2451             :                         "pg_extension_config_dump()")));
    2452             : 
    2453             :     /*
    2454             :      * Check that the table exists and is a member of the extension being
    2455             :      * created.  This ensures that we don't need to register an additional
    2456             :      * dependency to protect the extconfig entry.
    2457             :      */
    2458           8 :     tablename = get_rel_name(tableoid);
    2459           8 :     if (tablename == NULL)
    2460           0 :         ereport(ERROR,
    2461             :                 (errcode(ERRCODE_UNDEFINED_TABLE),
    2462             :                  errmsg("OID %u does not refer to a table", tableoid)));
    2463           8 :     if (getExtensionOfObject(RelationRelationId, tableoid) !=
    2464             :         CurrentExtensionObject)
    2465           0 :         ereport(ERROR,
    2466             :                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    2467             :                  errmsg("table \"%s\" is not a member of the extension being created",
    2468             :                         tablename)));
    2469             : 
    2470             :     /*
    2471             :      * Add the table OID and WHERE condition to the extension's extconfig and
    2472             :      * extcondition arrays.
    2473             :      *
    2474             :      * If the table is already in extconfig, treat this as an update of the
    2475             :      * WHERE condition.
    2476             :      */
    2477             : 
    2478             :     /* Find the pg_extension tuple */
    2479           8 :     extRel = table_open(ExtensionRelationId, RowExclusiveLock);
    2480             : 
    2481           8 :     ScanKeyInit(&key[0],
    2482             :                 Anum_pg_extension_oid,
    2483             :                 BTEqualStrategyNumber, F_OIDEQ,
    2484             :                 ObjectIdGetDatum(CurrentExtensionObject));
    2485             : 
    2486           8 :     extScan = systable_beginscan(extRel, ExtensionOidIndexId, true,
    2487             :                                  NULL, 1, key);
    2488             : 
    2489           8 :     extTup = systable_getnext(extScan);
    2490             : 
    2491           8 :     if (!HeapTupleIsValid(extTup))  /* should not happen */
    2492           0 :         elog(ERROR, "could not find tuple for extension %u",
    2493             :              CurrentExtensionObject);
    2494             : 
    2495           8 :     memset(repl_val, 0, sizeof(repl_val));
    2496           8 :     memset(repl_null, false, sizeof(repl_null));
    2497           8 :     memset(repl_repl, false, sizeof(repl_repl));
    2498             : 
    2499             :     /* Build or modify the extconfig value */
    2500           8 :     elementDatum = ObjectIdGetDatum(tableoid);
    2501             : 
    2502           8 :     arrayDatum = heap_getattr(extTup, Anum_pg_extension_extconfig,
    2503             :                               RelationGetDescr(extRel), &isnull);
    2504           8 :     if (isnull)
    2505             :     {
    2506             :         /* Previously empty extconfig, so build 1-element array */
    2507           4 :         arrayLength = 0;
    2508           4 :         arrayIndex = 1;
    2509             : 
    2510           4 :         a = construct_array_builtin(&elementDatum, 1, OIDOID);
    2511             :     }
    2512             :     else
    2513             :     {
    2514             :         /* Modify or extend existing extconfig array */
    2515             :         Oid        *arrayData;
    2516             :         int         i;
    2517             : 
    2518           4 :         a = DatumGetArrayTypeP(arrayDatum);
    2519             : 
    2520           4 :         arrayLength = ARR_DIMS(a)[0];
    2521           4 :         if (ARR_NDIM(a) != 1 ||
    2522           4 :             ARR_LBOUND(a)[0] != 1 ||
    2523           4 :             arrayLength < 0 ||
    2524           4 :             ARR_HASNULL(a) ||
    2525           4 :             ARR_ELEMTYPE(a) != OIDOID)
    2526           0 :             elog(ERROR, "extconfig is not a 1-D Oid array");
    2527           4 :         arrayData = (Oid *) ARR_DATA_PTR(a);
    2528             : 
    2529           4 :         arrayIndex = arrayLength + 1;   /* set up to add after end */
    2530             : 
    2531           8 :         for (i = 0; i < arrayLength; i++)
    2532             :         {
    2533           4 :             if (arrayData[i] == tableoid)
    2534             :             {
    2535           0 :                 arrayIndex = i + 1; /* replace this element instead */
    2536           0 :                 break;
    2537             :             }
    2538             :         }
    2539             : 
    2540           4 :         a = array_set(a, 1, &arrayIndex,
    2541             :                       elementDatum,
    2542             :                       false,
    2543             :                       -1 /* varlena array */ ,
    2544             :                       sizeof(Oid) /* OID's typlen */ ,
    2545             :                       true /* OID's typbyval */ ,
    2546             :                       TYPALIGN_INT /* OID's typalign */ );
    2547             :     }
    2548           8 :     repl_val[Anum_pg_extension_extconfig - 1] = PointerGetDatum(a);
    2549           8 :     repl_repl[Anum_pg_extension_extconfig - 1] = true;
    2550             : 
    2551             :     /* Build or modify the extcondition value */
    2552           8 :     elementDatum = PointerGetDatum(wherecond);
    2553             : 
    2554           8 :     arrayDatum = heap_getattr(extTup, Anum_pg_extension_extcondition,
    2555             :                               RelationGetDescr(extRel), &isnull);
    2556           8 :     if (isnull)
    2557             :     {
    2558           4 :         if (arrayLength != 0)
    2559           0 :             elog(ERROR, "extconfig and extcondition arrays do not match");
    2560             : 
    2561           4 :         a = construct_array_builtin(&elementDatum, 1, TEXTOID);
    2562             :     }
    2563             :     else
    2564             :     {
    2565           4 :         a = DatumGetArrayTypeP(arrayDatum);
    2566             : 
    2567           4 :         if (ARR_NDIM(a) != 1 ||
    2568           4 :             ARR_LBOUND(a)[0] != 1 ||
    2569           4 :             ARR_HASNULL(a) ||
    2570           4 :             ARR_ELEMTYPE(a) != TEXTOID)
    2571           0 :             elog(ERROR, "extcondition is not a 1-D text array");
    2572           4 :         if (ARR_DIMS(a)[0] != arrayLength)
    2573           0 :             elog(ERROR, "extconfig and extcondition arrays do not match");
    2574             : 
    2575             :         /* Add or replace at same index as in extconfig */
    2576           4 :         a = array_set(a, 1, &arrayIndex,
    2577             :                       elementDatum,
    2578             :                       false,
    2579             :                       -1 /* varlena array */ ,
    2580             :                       -1 /* TEXT's typlen */ ,
    2581             :                       false /* TEXT's typbyval */ ,
    2582             :                       TYPALIGN_INT /* TEXT's typalign */ );
    2583             :     }
    2584           8 :     repl_val[Anum_pg_extension_extcondition - 1] = PointerGetDatum(a);
    2585           8 :     repl_repl[Anum_pg_extension_extcondition - 1] = true;
    2586             : 
    2587           8 :     extTup = heap_modify_tuple(extTup, RelationGetDescr(extRel),
    2588             :                                repl_val, repl_null, repl_repl);
    2589             : 
    2590           8 :     CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
    2591             : 
    2592           8 :     systable_endscan(extScan);
    2593             : 
    2594           8 :     table_close(extRel, RowExclusiveLock);
    2595             : 
    2596           8 :     PG_RETURN_VOID();
    2597             : }
    2598             : 
    2599             : /*
    2600             :  * extension_config_remove
    2601             :  *
    2602             :  * Remove the specified table OID from extension's extconfig, if present.
    2603             :  * This is not currently exposed as a function, but it could be;
    2604             :  * for now, we just invoke it from ALTER EXTENSION DROP.
    2605             :  */
    2606             : static void
    2607          40 : extension_config_remove(Oid extensionoid, Oid tableoid)
    2608             : {
    2609             :     Relation    extRel;
    2610             :     ScanKeyData key[1];
    2611             :     SysScanDesc extScan;
    2612             :     HeapTuple   extTup;
    2613             :     Datum       arrayDatum;
    2614             :     int         arrayLength;
    2615             :     int         arrayIndex;
    2616             :     bool        isnull;
    2617             :     Datum       repl_val[Natts_pg_extension];
    2618             :     bool        repl_null[Natts_pg_extension];
    2619             :     bool        repl_repl[Natts_pg_extension];
    2620             :     ArrayType  *a;
    2621             : 
    2622             :     /* Find the pg_extension tuple */
    2623          40 :     extRel = table_open(ExtensionRelationId, RowExclusiveLock);
    2624             : 
    2625          40 :     ScanKeyInit(&key[0],
    2626             :                 Anum_pg_extension_oid,
    2627             :                 BTEqualStrategyNumber, F_OIDEQ,
    2628             :                 ObjectIdGetDatum(extensionoid));
    2629             : 
    2630          40 :     extScan = systable_beginscan(extRel, ExtensionOidIndexId, true,
    2631             :                                  NULL, 1, key);
    2632             : 
    2633          40 :     extTup = systable_getnext(extScan);
    2634             : 
    2635          40 :     if (!HeapTupleIsValid(extTup))  /* should not happen */
    2636           0 :         elog(ERROR, "could not find tuple for extension %u",
    2637             :              extensionoid);
    2638             : 
    2639             :     /* Search extconfig for the tableoid */
    2640          40 :     arrayDatum = heap_getattr(extTup, Anum_pg_extension_extconfig,
    2641             :                               RelationGetDescr(extRel), &isnull);
    2642          40 :     if (isnull)
    2643             :     {
    2644             :         /* nothing to do */
    2645          32 :         a = NULL;
    2646          32 :         arrayLength = 0;
    2647          32 :         arrayIndex = -1;
    2648             :     }
    2649             :     else
    2650             :     {
    2651             :         Oid        *arrayData;
    2652             :         int         i;
    2653             : 
    2654           8 :         a = DatumGetArrayTypeP(arrayDatum);
    2655             : 
    2656           8 :         arrayLength = ARR_DIMS(a)[0];
    2657           8 :         if (ARR_NDIM(a) != 1 ||
    2658           8 :             ARR_LBOUND(a)[0] != 1 ||
    2659           8 :             arrayLength < 0 ||
    2660           8 :             ARR_HASNULL(a) ||
    2661           8 :             ARR_ELEMTYPE(a) != OIDOID)
    2662           0 :             elog(ERROR, "extconfig is not a 1-D Oid array");
    2663           8 :         arrayData = (Oid *) ARR_DATA_PTR(a);
    2664             : 
    2665           8 :         arrayIndex = -1;        /* flag for no deletion needed */
    2666             : 
    2667          24 :         for (i = 0; i < arrayLength; i++)
    2668             :         {
    2669          16 :             if (arrayData[i] == tableoid)
    2670             :             {
    2671           0 :                 arrayIndex = i; /* index to remove */
    2672           0 :                 break;
    2673             :             }
    2674             :         }
    2675             :     }
    2676             : 
    2677             :     /* If tableoid is not in extconfig, nothing to do */
    2678          40 :     if (arrayIndex < 0)
    2679             :     {
    2680          40 :         systable_endscan(extScan);
    2681          40 :         table_close(extRel, RowExclusiveLock);
    2682          40 :         return;
    2683             :     }
    2684             : 
    2685             :     /* Modify or delete the extconfig value */
    2686           0 :     memset(repl_val, 0, sizeof(repl_val));
    2687           0 :     memset(repl_null, false, sizeof(repl_null));
    2688           0 :     memset(repl_repl, false, sizeof(repl_repl));
    2689             : 
    2690           0 :     if (arrayLength <= 1)
    2691             :     {
    2692             :         /* removing only element, just set array to null */
    2693           0 :         repl_null[Anum_pg_extension_extconfig - 1] = true;
    2694             :     }
    2695             :     else
    2696             :     {
    2697             :         /* squeeze out the target element */
    2698             :         Datum      *dvalues;
    2699             :         int         nelems;
    2700             :         int         i;
    2701             : 
    2702             :         /* We already checked there are no nulls */
    2703           0 :         deconstruct_array_builtin(a, OIDOID, &dvalues, NULL, &nelems);
    2704             : 
    2705           0 :         for (i = arrayIndex; i < arrayLength - 1; i++)
    2706           0 :             dvalues[i] = dvalues[i + 1];
    2707             : 
    2708           0 :         a = construct_array_builtin(dvalues, arrayLength - 1, OIDOID);
    2709             : 
    2710           0 :         repl_val[Anum_pg_extension_extconfig - 1] = PointerGetDatum(a);
    2711             :     }
    2712           0 :     repl_repl[Anum_pg_extension_extconfig - 1] = true;
    2713             : 
    2714             :     /* Modify or delete the extcondition value */
    2715           0 :     arrayDatum = heap_getattr(extTup, Anum_pg_extension_extcondition,
    2716             :                               RelationGetDescr(extRel), &isnull);
    2717           0 :     if (isnull)
    2718             :     {
    2719           0 :         elog(ERROR, "extconfig and extcondition arrays do not match");
    2720             :     }
    2721             :     else
    2722             :     {
    2723           0 :         a = DatumGetArrayTypeP(arrayDatum);
    2724             : 
    2725           0 :         if (ARR_NDIM(a) != 1 ||
    2726           0 :             ARR_LBOUND(a)[0] != 1 ||
    2727           0 :             ARR_HASNULL(a) ||
    2728           0 :             ARR_ELEMTYPE(a) != TEXTOID)
    2729           0 :             elog(ERROR, "extcondition is not a 1-D text array");
    2730           0 :         if (ARR_DIMS(a)[0] != arrayLength)
    2731           0 :             elog(ERROR, "extconfig and extcondition arrays do not match");
    2732             :     }
    2733             : 
    2734           0 :     if (arrayLength <= 1)
    2735             :     {
    2736             :         /* removing only element, just set array to null */
    2737           0 :         repl_null[Anum_pg_extension_extcondition - 1] = true;
    2738             :     }
    2739             :     else
    2740             :     {
    2741             :         /* squeeze out the target element */
    2742             :         Datum      *dvalues;
    2743             :         int         nelems;
    2744             :         int         i;
    2745             : 
    2746             :         /* We already checked there are no nulls */
    2747           0 :         deconstruct_array_builtin(a, TEXTOID, &dvalues, NULL, &nelems);
    2748             : 
    2749           0 :         for (i = arrayIndex; i < arrayLength - 1; i++)
    2750           0 :             dvalues[i] = dvalues[i + 1];
    2751             : 
    2752           0 :         a = construct_array_builtin(dvalues, arrayLength - 1, TEXTOID);
    2753             : 
    2754           0 :         repl_val[Anum_pg_extension_extcondition - 1] = PointerGetDatum(a);
    2755             :     }
    2756           0 :     repl_repl[Anum_pg_extension_extcondition - 1] = true;
    2757             : 
    2758           0 :     extTup = heap_modify_tuple(extTup, RelationGetDescr(extRel),
    2759             :                                repl_val, repl_null, repl_repl);
    2760             : 
    2761           0 :     CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
    2762             : 
    2763           0 :     systable_endscan(extScan);
    2764             : 
    2765           0 :     table_close(extRel, RowExclusiveLock);
    2766             : }
    2767             : 
    2768             : /*
    2769             :  * Execute ALTER EXTENSION SET SCHEMA
    2770             :  */
    2771             : ObjectAddress
    2772          10 : AlterExtensionNamespace(const char *extensionName, const char *newschema, Oid *oldschema)
    2773             : {
    2774             :     Oid         extensionOid;
    2775             :     Oid         nspOid;
    2776             :     Oid         oldNspOid;
    2777             :     AclResult   aclresult;
    2778             :     Relation    extRel;
    2779             :     ScanKeyData key[2];
    2780             :     SysScanDesc extScan;
    2781             :     HeapTuple   extTup;
    2782             :     Form_pg_extension extForm;
    2783             :     Relation    depRel;
    2784             :     SysScanDesc depScan;
    2785             :     HeapTuple   depTup;
    2786             :     ObjectAddresses *objsMoved;
    2787             :     ObjectAddress extAddr;
    2788             : 
    2789          10 :     extensionOid = get_extension_oid(extensionName, false);
    2790             : 
    2791          10 :     nspOid = LookupCreationNamespace(newschema);
    2792             : 
    2793             :     /*
    2794             :      * Permission check: must own extension.  Note that we don't bother to
    2795             :      * check ownership of the individual member objects ...
    2796             :      */
    2797          10 :     if (!object_ownercheck(ExtensionRelationId, extensionOid, GetUserId()))
    2798           0 :         aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EXTENSION,
    2799             :                        extensionName);
    2800             : 
    2801             :     /* Permission check: must have creation rights in target namespace */
    2802          10 :     aclresult = object_aclcheck(NamespaceRelationId, nspOid, GetUserId(), ACL_CREATE);
    2803          10 :     if (aclresult != ACLCHECK_OK)
    2804           0 :         aclcheck_error(aclresult, OBJECT_SCHEMA, newschema);
    2805             : 
    2806             :     /*
    2807             :      * If the schema is currently a member of the extension, disallow moving
    2808             :      * the extension into the schema.  That would create a dependency loop.
    2809             :      */
    2810          10 :     if (getExtensionOfObject(NamespaceRelationId, nspOid) == extensionOid)
    2811           0 :         ereport(ERROR,
    2812             :                 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    2813             :                  errmsg("cannot move extension \"%s\" into schema \"%s\" "
    2814             :                         "because the extension contains the schema",
    2815             :                         extensionName, newschema)));
    2816             : 
    2817             :     /* Locate the pg_extension tuple */
    2818          10 :     extRel = table_open(ExtensionRelationId, RowExclusiveLock);
    2819             : 
    2820          10 :     ScanKeyInit(&key[0],
    2821             :                 Anum_pg_extension_oid,
    2822             :                 BTEqualStrategyNumber, F_OIDEQ,
    2823             :                 ObjectIdGetDatum(extensionOid));
    2824             : 
    2825          10 :     extScan = systable_beginscan(extRel, ExtensionOidIndexId, true,
    2826             :                                  NULL, 1, key);
    2827             : 
    2828          10 :     extTup = systable_getnext(extScan);
    2829             : 
    2830          10 :     if (!HeapTupleIsValid(extTup))  /* should not happen */
    2831           0 :         elog(ERROR, "could not find tuple for extension %u",
    2832             :              extensionOid);
    2833             : 
    2834             :     /* Copy tuple so we can modify it below */
    2835          10 :     extTup = heap_copytuple(extTup);
    2836          10 :     extForm = (Form_pg_extension) GETSTRUCT(extTup);
    2837             : 
    2838          10 :     systable_endscan(extScan);
    2839             : 
    2840             :     /*
    2841             :      * If the extension is already in the target schema, just silently do
    2842             :      * nothing.
    2843             :      */
    2844          10 :     if (extForm->extnamespace == nspOid)
    2845             :     {
    2846           0 :         table_close(extRel, RowExclusiveLock);
    2847           0 :         return InvalidObjectAddress;
    2848             :     }
    2849             : 
    2850             :     /* Check extension is supposed to be relocatable */
    2851          10 :     if (!extForm->extrelocatable)
    2852           0 :         ereport(ERROR,
    2853             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    2854             :                  errmsg("extension \"%s\" does not support SET SCHEMA",
    2855             :                         NameStr(extForm->extname))));
    2856             : 
    2857          10 :     objsMoved = new_object_addresses();
    2858             : 
    2859             :     /* store the OID of the namespace to-be-changed */
    2860          10 :     oldNspOid = extForm->extnamespace;
    2861             : 
    2862             :     /*
    2863             :      * Scan pg_depend to find objects that depend directly on the extension,
    2864             :      * and alter each one's schema.
    2865             :      */
    2866          10 :     depRel = table_open(DependRelationId, AccessShareLock);
    2867             : 
    2868          10 :     ScanKeyInit(&key[0],
    2869             :                 Anum_pg_depend_refclassid,
    2870             :                 BTEqualStrategyNumber, F_OIDEQ,
    2871             :                 ObjectIdGetDatum(ExtensionRelationId));
    2872          10 :     ScanKeyInit(&key[1],
    2873             :                 Anum_pg_depend_refobjid,
    2874             :                 BTEqualStrategyNumber, F_OIDEQ,
    2875             :                 ObjectIdGetDatum(extensionOid));
    2876             : 
    2877          10 :     depScan = systable_beginscan(depRel, DependReferenceIndexId, true,
    2878             :                                  NULL, 2, key);
    2879             : 
    2880          24 :     while (HeapTupleIsValid(depTup = systable_getnext(depScan)))
    2881             :     {
    2882          18 :         Form_pg_depend pg_depend = (Form_pg_depend) GETSTRUCT(depTup);
    2883             :         ObjectAddress dep;
    2884             :         Oid         dep_oldNspOid;
    2885             : 
    2886             :         /*
    2887             :          * If a dependent extension has a no_relocate request for this
    2888             :          * extension, disallow SET SCHEMA.  (XXX it's a bit ugly to do this in
    2889             :          * the same loop that's actually executing the renames: we may detect
    2890             :          * the error condition only after having expended a fair amount of
    2891             :          * work.  However, the alternative is to do two scans of pg_depend,
    2892             :          * which seems like optimizing for failure cases.  The rename work
    2893             :          * will all roll back cleanly enough if we do fail here.)
    2894             :          */
    2895          18 :         if (pg_depend->deptype == DEPENDENCY_NORMAL &&
    2896           8 :             pg_depend->classid == ExtensionRelationId)
    2897             :         {
    2898           8 :             char       *depextname = get_extension_name(pg_depend->objid);
    2899             :             ExtensionControlFile *dcontrol;
    2900             :             ListCell   *lc;
    2901             : 
    2902           8 :             dcontrol = read_extension_control_file(depextname);
    2903          10 :             foreach(lc, dcontrol->no_relocate)
    2904             :             {
    2905           4 :                 char       *nrextname = (char *) lfirst(lc);
    2906             : 
    2907           4 :                 if (strcmp(nrextname, NameStr(extForm->extname)) == 0)
    2908             :                 {
    2909           2 :                     ereport(ERROR,
    2910             :                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    2911             :                              errmsg("cannot SET SCHEMA of extension \"%s\" because other extensions prevent it",
    2912             :                                     NameStr(extForm->extname)),
    2913             :                              errdetail("Extension \"%s\" requests no relocation of extension \"%s\".",
    2914             :                                        depextname,
    2915             :                                        NameStr(extForm->extname))));
    2916             :                 }
    2917             :             }
    2918             :         }
    2919             : 
    2920             :         /*
    2921             :          * Otherwise, ignore non-membership dependencies.  (Currently, the
    2922             :          * only other case we could see here is a normal dependency from
    2923             :          * another extension.)
    2924             :          */
    2925          16 :         if (pg_depend->deptype != DEPENDENCY_EXTENSION)
    2926           6 :             continue;
    2927             : 
    2928          10 :         dep.classId = pg_depend->classid;
    2929          10 :         dep.objectId = pg_depend->objid;
    2930          10 :         dep.objectSubId = pg_depend->objsubid;
    2931             : 
    2932          10 :         if (dep.objectSubId != 0)   /* should not happen */
    2933           0 :             elog(ERROR, "extension should not have a sub-object dependency");
    2934             : 
    2935             :         /* Relocate the object */
    2936          10 :         dep_oldNspOid = AlterObjectNamespace_oid(dep.classId,
    2937             :                                                  dep.objectId,
    2938             :                                                  nspOid,
    2939             :                                                  objsMoved);
    2940             : 
    2941             :         /*
    2942             :          * If not all the objects had the same old namespace (ignoring any
    2943             :          * that are not in namespaces), complain.
    2944             :          */
    2945          10 :         if (dep_oldNspOid != InvalidOid && dep_oldNspOid != oldNspOid)
    2946           2 :             ereport(ERROR,
    2947             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    2948             :                      errmsg("extension \"%s\" does not support SET SCHEMA",
    2949             :                             NameStr(extForm->extname)),
    2950             :                      errdetail("%s is not in the extension's schema \"%s\"",
    2951             :                                getObjectDescription(&dep, false),
    2952             :                                get_namespace_name(oldNspOid))));
    2953             :     }
    2954             : 
    2955             :     /* report old schema, if caller wants it */
    2956           6 :     if (oldschema)
    2957           6 :         *oldschema = oldNspOid;
    2958             : 
    2959           6 :     systable_endscan(depScan);
    2960             : 
    2961           6 :     relation_close(depRel, AccessShareLock);
    2962             : 
    2963             :     /* Now adjust pg_extension.extnamespace */
    2964           6 :     extForm->extnamespace = nspOid;
    2965             : 
    2966           6 :     CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
    2967             : 
    2968           6 :     table_close(extRel, RowExclusiveLock);
    2969             : 
    2970             :     /* update dependency to point to the new schema */
    2971           6 :     if (changeDependencyFor(ExtensionRelationId, extensionOid,
    2972             :                             NamespaceRelationId, oldNspOid, nspOid) != 1)
    2973           0 :         elog(ERROR, "could not change schema dependency for extension %s",
    2974             :              NameStr(extForm->extname));
    2975             : 
    2976           6 :     InvokeObjectPostAlterHook(ExtensionRelationId, extensionOid, 0);
    2977             : 
    2978           6 :     ObjectAddressSet(extAddr, ExtensionRelationId, extensionOid);
    2979             : 
    2980           6 :     return extAddr;
    2981             : }
    2982             : 
    2983             : /*
    2984             :  * Execute ALTER EXTENSION UPDATE
    2985             :  */
    2986             : ObjectAddress
    2987          26 : ExecAlterExtensionStmt(ParseState *pstate, AlterExtensionStmt *stmt)
    2988             : {
    2989          26 :     DefElem    *d_new_version = NULL;
    2990             :     char       *versionName;
    2991             :     char       *oldVersionName;
    2992             :     ExtensionControlFile *control;
    2993             :     Oid         extensionOid;
    2994             :     Relation    extRel;
    2995             :     ScanKeyData key[1];
    2996             :     SysScanDesc extScan;
    2997             :     HeapTuple   extTup;
    2998             :     List       *updateVersions;
    2999             :     Datum       datum;
    3000             :     bool        isnull;
    3001             :     ListCell   *lc;
    3002             :     ObjectAddress address;
    3003             : 
    3004             :     /*
    3005             :      * We use global variables to track the extension being created, so we can
    3006             :      * create/update only one extension at the same time.
    3007             :      */
    3008          26 :     if (creating_extension)
    3009           0 :         ereport(ERROR,
    3010             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    3011             :                  errmsg("nested ALTER EXTENSION is not supported")));
    3012             : 
    3013             :     /*
    3014             :      * Look up the extension --- it must already exist in pg_extension
    3015             :      */
    3016          26 :     extRel = table_open(ExtensionRelationId, AccessShareLock);
    3017             : 
    3018          26 :     ScanKeyInit(&key[0],
    3019             :                 Anum_pg_extension_extname,
    3020             :                 BTEqualStrategyNumber, F_NAMEEQ,
    3021          26 :                 CStringGetDatum(stmt->extname));
    3022             : 
    3023          26 :     extScan = systable_beginscan(extRel, ExtensionNameIndexId, true,
    3024             :                                  NULL, 1, key);
    3025             : 
    3026          26 :     extTup = systable_getnext(extScan);
    3027             : 
    3028          26 :     if (!HeapTupleIsValid(extTup))
    3029           0 :         ereport(ERROR,
    3030             :                 (errcode(ERRCODE_UNDEFINED_OBJECT),
    3031             :                  errmsg("extension \"%s\" does not exist",
    3032             :                         stmt->extname)));
    3033             : 
    3034          26 :     extensionOid = ((Form_pg_extension) GETSTRUCT(extTup))->oid;
    3035             : 
    3036             :     /*
    3037             :      * Determine the existing version we are updating from
    3038             :      */
    3039          26 :     datum = heap_getattr(extTup, Anum_pg_extension_extversion,
    3040             :                          RelationGetDescr(extRel), &isnull);
    3041          26 :     if (isnull)
    3042           0 :         elog(ERROR, "extversion is null");
    3043          26 :     oldVersionName = text_to_cstring(DatumGetTextPP(datum));
    3044             : 
    3045          26 :     systable_endscan(extScan);
    3046             : 
    3047          26 :     table_close(extRel, AccessShareLock);
    3048             : 
    3049             :     /* Permission check: must own extension */
    3050          26 :     if (!object_ownercheck(ExtensionRelationId, extensionOid, GetUserId()))
    3051           0 :         aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EXTENSION,
    3052           0 :                        stmt->extname);
    3053             : 
    3054             :     /*
    3055             :      * Read the primary control file.  Note we assume that it does not contain
    3056             :      * any non-ASCII data, so there is no need to worry about encoding at this
    3057             :      * point.
    3058             :      */
    3059          26 :     control = read_extension_control_file(stmt->extname);
    3060             : 
    3061             :     /*
    3062             :      * Read the statement option list
    3063             :      */
    3064          52 :     foreach(lc, stmt->options)
    3065             :     {
    3066          26 :         DefElem    *defel = (DefElem *) lfirst(lc);
    3067             : 
    3068          26 :         if (strcmp(defel->defname, "new_version") == 0)
    3069             :         {
    3070          26 :             if (d_new_version)
    3071           0 :                 errorConflictingDefElem(defel, pstate);
    3072          26 :             d_new_version = defel;
    3073             :         }
    3074             :         else
    3075           0 :             elog(ERROR, "unrecognized option: %s", defel->defname);
    3076             :     }
    3077             : 
    3078             :     /*
    3079             :      * Determine the version to update to
    3080             :      */
    3081          26 :     if (d_new_version && d_new_version->arg)
    3082          26 :         versionName = strVal(d_new_version->arg);
    3083           0 :     else if (control->default_version)
    3084           0 :         versionName = control->default_version;
    3085             :     else
    3086             :     {
    3087           0 :         ereport(ERROR,
    3088             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    3089             :                  errmsg("version to install must be specified")));
    3090             :         versionName = NULL;     /* keep compiler quiet */
    3091             :     }
    3092          26 :     check_valid_version_name(versionName);
    3093             : 
    3094             :     /*
    3095             :      * If we're already at that version, just say so
    3096             :      */
    3097          26 :     if (strcmp(oldVersionName, versionName) == 0)
    3098             :     {
    3099           0 :         ereport(NOTICE,
    3100             :                 (errmsg("version \"%s\" of extension \"%s\" is already installed",
    3101             :                         versionName, stmt->extname)));
    3102           0 :         return InvalidObjectAddress;
    3103             :     }
    3104             : 
    3105             :     /*
    3106             :      * Identify the series of update script files we need to execute
    3107             :      */
    3108          26 :     updateVersions = identify_update_path(control,
    3109             :                                           oldVersionName,
    3110             :                                           versionName);
    3111             : 
    3112             :     /*
    3113             :      * Update the pg_extension row and execute the update scripts, one at a
    3114             :      * time
    3115             :      */
    3116          26 :     ApplyExtensionUpdates(extensionOid, control,
    3117             :                           oldVersionName, updateVersions,
    3118             :                           NULL, false, false);
    3119             : 
    3120          26 :     ObjectAddressSet(address, ExtensionRelationId, extensionOid);
    3121             : 
    3122          26 :     return address;
    3123             : }
    3124             : 
    3125             : /*
    3126             :  * Apply a series of update scripts as though individual ALTER EXTENSION
    3127             :  * UPDATE commands had been given, including altering the pg_extension row
    3128             :  * and dependencies each time.
    3129             :  *
    3130             :  * This might be more work than necessary, but it ensures that old update
    3131             :  * scripts don't break if newer versions have different control parameters.
    3132             :  */
    3133             : static void
    3134         420 : ApplyExtensionUpdates(Oid extensionOid,
    3135             :                       ExtensionControlFile *pcontrol,
    3136             :                       const char *initialVersion,
    3137             :                       List *updateVersions,
    3138             :                       char *origSchemaName,
    3139             :                       bool cascade,
    3140             :                       bool is_create)
    3141             : {
    3142         420 :     const char *oldVersionName = initialVersion;
    3143             :     ListCell   *lcv;
    3144             : 
    3145         840 :     foreach(lcv, updateVersions)
    3146             :     {
    3147         420 :         char       *versionName = (char *) lfirst(lcv);
    3148             :         ExtensionControlFile *control;
    3149             :         char       *schemaName;
    3150             :         Oid         schemaOid;
    3151             :         List       *requiredExtensions;
    3152             :         List       *requiredSchemas;
    3153             :         Relation    extRel;
    3154             :         ScanKeyData key[1];
    3155             :         SysScanDesc extScan;
    3156             :         HeapTuple   extTup;
    3157             :         Form_pg_extension extForm;
    3158             :         Datum       values[Natts_pg_extension];
    3159             :         bool        nulls[Natts_pg_extension];
    3160             :         bool        repl[Natts_pg_extension];
    3161             :         ObjectAddress myself;
    3162             :         ListCell   *lc;
    3163             : 
    3164             :         /*
    3165             :          * Fetch parameters for specific version (pcontrol is not changed)
    3166             :          */
    3167         420 :         control = read_extension_aux_control_file(pcontrol, versionName);
    3168             : 
    3169             :         /* Find the pg_extension tuple */
    3170         420 :         extRel = table_open(ExtensionRelationId, RowExclusiveLock);
    3171             : 
    3172         420 :         ScanKeyInit(&key[0],
    3173             :                     Anum_pg_extension_oid,
    3174             :                     BTEqualStrategyNumber, F_OIDEQ,
    3175             :                     ObjectIdGetDatum(extensionOid));
    3176             : 
    3177         420 :         extScan = systable_beginscan(extRel, ExtensionOidIndexId, true,
    3178             :                                      NULL, 1, key);
    3179             : 
    3180         420 :         extTup = systable_getnext(extScan);
    3181             : 
    3182         420 :         if (!HeapTupleIsValid(extTup))  /* should not happen */
    3183           0 :             elog(ERROR, "could not find tuple for extension %u",
    3184             :                  extensionOid);
    3185             : 
    3186         420 :         extForm = (Form_pg_extension) GETSTRUCT(extTup);
    3187             : 
    3188             :         /*
    3189             :          * Determine the target schema (set by original install)
    3190             :          */
    3191         420 :         schemaOid = extForm->extnamespace;
    3192         420 :         schemaName = get_namespace_name(schemaOid);
    3193             : 
    3194             :         /*
    3195             :          * Modify extrelocatable and extversion in the pg_extension tuple
    3196             :          */
    3197         420 :         memset(values, 0, sizeof(values));
    3198         420 :         memset(nulls, 0, sizeof(nulls));
    3199         420 :         memset(repl, 0, sizeof(repl));
    3200             : 
    3201         420 :         values[Anum_pg_extension_extrelocatable - 1] =
    3202         420 :             BoolGetDatum(control->relocatable);
    3203         420 :         repl[Anum_pg_extension_extrelocatable - 1] = true;
    3204         420 :         values[Anum_pg_extension_extversion - 1] =
    3205         420 :             CStringGetTextDatum(versionName);
    3206         420 :         repl[Anum_pg_extension_extversion - 1] = true;
    3207             : 
    3208         420 :         extTup = heap_modify_tuple(extTup, RelationGetDescr(extRel),
    3209             :                                    values, nulls, repl);
    3210             : 
    3211         420 :         CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
    3212             : 
    3213         420 :         systable_endscan(extScan);
    3214             : 
    3215         420 :         table_close(extRel, RowExclusiveLock);
    3216             : 
    3217             :         /*
    3218             :          * Look up the prerequisite extensions for this version, install them
    3219             :          * if necessary, and build lists of their OIDs and the OIDs of their
    3220             :          * target schemas.
    3221             :          */
    3222         420 :         requiredExtensions = NIL;
    3223         420 :         requiredSchemas = NIL;
    3224         420 :         foreach(lc, control->requires)
    3225             :         {
    3226           0 :             char       *curreq = (char *) lfirst(lc);
    3227             :             Oid         reqext;
    3228             :             Oid         reqschema;
    3229             : 
    3230           0 :             reqext = get_required_extension(curreq,
    3231             :                                             control->name,
    3232             :                                             origSchemaName,
    3233             :                                             cascade,
    3234             :                                             NIL,
    3235             :                                             is_create);
    3236           0 :             reqschema = get_extension_schema(reqext);
    3237           0 :             requiredExtensions = lappend_oid(requiredExtensions, reqext);
    3238           0 :             requiredSchemas = lappend_oid(requiredSchemas, reqschema);
    3239             :         }
    3240             : 
    3241             :         /*
    3242             :          * Remove and recreate dependencies on prerequisite extensions
    3243             :          */
    3244         420 :         deleteDependencyRecordsForClass(ExtensionRelationId, extensionOid,
    3245             :                                         ExtensionRelationId,
    3246             :                                         DEPENDENCY_NORMAL);
    3247             : 
    3248         420 :         myself.classId = ExtensionRelationId;
    3249         420 :         myself.objectId = extensionOid;
    3250         420 :         myself.objectSubId = 0;
    3251             : 
    3252         420 :         foreach(lc, requiredExtensions)
    3253             :         {
    3254           0 :             Oid         reqext = lfirst_oid(lc);
    3255             :             ObjectAddress otherext;
    3256             : 
    3257           0 :             otherext.classId = ExtensionRelationId;
    3258           0 :             otherext.objectId = reqext;
    3259           0 :             otherext.objectSubId = 0;
    3260             : 
    3261           0 :             recordDependencyOn(&myself, &otherext, DEPENDENCY_NORMAL);
    3262             :         }
    3263             : 
    3264         420 :         InvokeObjectPostAlterHook(ExtensionRelationId, extensionOid, 0);
    3265             : 
    3266             :         /*
    3267             :          * Finally, execute the update script file
    3268             :          */
    3269         420 :         execute_extension_script(extensionOid, control,
    3270             :                                  oldVersionName, versionName,
    3271             :                                  requiredSchemas,
    3272             :                                  schemaName, schemaOid);
    3273             : 
    3274             :         /*
    3275             :          * Update prior-version name and loop around.  Since
    3276             :          * execute_sql_string did a final CommandCounterIncrement, we can
    3277             :          * update the pg_extension row again.
    3278             :          */
    3279         420 :         oldVersionName = versionName;
    3280             :     }
    3281         420 : }
    3282             : 
    3283             : /*
    3284             :  * Execute ALTER EXTENSION ADD/DROP
    3285             :  *
    3286             :  * Return value is the address of the altered extension.
    3287             :  *
    3288             :  * objAddr is an output argument which, if not NULL, is set to the address of
    3289             :  * the added/dropped object.
    3290             :  */
    3291             : ObjectAddress
    3292         200 : ExecAlterExtensionContentsStmt(AlterExtensionContentsStmt *stmt,
    3293             :                                ObjectAddress *objAddr)
    3294             : {
    3295             :     ObjectAddress extension;
    3296             :     ObjectAddress object;
    3297             :     Relation    relation;
    3298             : 
    3299         200 :     switch (stmt->objtype)
    3300             :     {
    3301           2 :         case OBJECT_DATABASE:
    3302             :         case OBJECT_EXTENSION:
    3303             :         case OBJECT_INDEX:
    3304             :         case OBJECT_PUBLICATION:
    3305             :         case OBJECT_ROLE:
    3306             :         case OBJECT_STATISTIC_EXT:
    3307             :         case OBJECT_SUBSCRIPTION:
    3308             :         case OBJECT_TABLESPACE:
    3309           2 :             ereport(ERROR,
    3310             :                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
    3311             :                      errmsg("cannot add an object of this type to an extension")));
    3312             :             break;
    3313         198 :         default:
    3314             :             /* OK */
    3315         198 :             break;
    3316             :     }
    3317             : 
    3318             :     /*
    3319             :      * Find the extension and acquire a lock on it, to ensure it doesn't get
    3320             :      * dropped concurrently.  A sharable lock seems sufficient: there's no
    3321             :      * reason not to allow other sorts of manipulations, such as add/drop of
    3322             :      * other objects, to occur concurrently.  Concurrently adding/dropping the
    3323             :      * *same* object would be bad, but we prevent that by using a non-sharable
    3324             :      * lock on the individual object, below.
    3325             :      */
    3326         198 :     extension = get_object_address(OBJECT_EXTENSION,
    3327         198 :                                    (Node *) makeString(stmt->extname),
    3328             :                                    &relation, AccessShareLock, false);
    3329             : 
    3330             :     /* Permission check: must own extension */
    3331         198 :     if (!object_ownercheck(ExtensionRelationId, extension.objectId, GetUserId()))
    3332           0 :         aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EXTENSION,
    3333           0 :                        stmt->extname);
    3334             : 
    3335             :     /*
    3336             :      * Translate the parser representation that identifies the object into an
    3337             :      * ObjectAddress.  get_object_address() will throw an error if the object
    3338             :      * does not exist, and will also acquire a lock on the object to guard
    3339             :      * against concurrent DROP and ALTER EXTENSION ADD/DROP operations.
    3340             :      */
    3341         198 :     object = get_object_address(stmt->objtype, stmt->object,
    3342             :                                 &relation, ShareUpdateExclusiveLock, false);
    3343             : 
    3344             :     Assert(object.objectSubId == 0);
    3345         198 :     if (objAddr)
    3346         198 :         *objAddr = object;
    3347             : 
    3348             :     /* Permission check: must own target object, too */
    3349         198 :     check_object_ownership(GetUserId(), stmt->objtype, object,
    3350             :                            stmt->object, relation);
    3351             : 
    3352             :     /* Do the update, recursing to any dependent objects */
    3353         198 :     ExecAlterExtensionContentsRecurse(stmt, extension, object);
    3354             : 
    3355             :     /* Finish up */
    3356         198 :     InvokeObjectPostAlterHook(ExtensionRelationId, extension.objectId, 0);
    3357             : 
    3358             :     /*
    3359             :      * If get_object_address() opened the relation for us, we close it to keep
    3360             :      * the reference count correct - but we retain any locks acquired by
    3361             :      * get_object_address() until commit time, to guard against concurrent
    3362             :      * activity.
    3363             :      */
    3364         198 :     if (relation != NULL)
    3365          56 :         relation_close(relation, NoLock);
    3366             : 
    3367         198 :     return extension;
    3368             : }
    3369             : 
    3370             : /*
    3371             :  * ExecAlterExtensionContentsRecurse
    3372             :  *      Subroutine for ExecAlterExtensionContentsStmt
    3373             :  *
    3374             :  * Do the bare alteration of object's membership in extension,
    3375             :  * without permission checks.  Recurse to dependent objects, if any.
    3376             :  */
    3377             : static void
    3378         322 : ExecAlterExtensionContentsRecurse(AlterExtensionContentsStmt *stmt,
    3379             :                                   ObjectAddress extension,
    3380             :                                   ObjectAddress object)
    3381             : {
    3382             :     Oid         oldExtension;
    3383             : 
    3384             :     /*
    3385             :      * Check existing extension membership.
    3386             :      */
    3387         322 :     oldExtension = getExtensionOfObject(object.classId, object.objectId);
    3388             : 
    3389         322 :     if (stmt->action > 0)
    3390             :     {
    3391             :         /*
    3392             :          * ADD, so complain if object is already attached to some extension.
    3393             :          */
    3394          96 :         if (OidIsValid(oldExtension))
    3395           0 :             ereport(ERROR,
    3396             :                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    3397             :                      errmsg("%s is already a member of extension \"%s\"",
    3398             :                             getObjectDescription(&object, false),
    3399             :                             get_extension_name(oldExtension))));
    3400             : 
    3401             :         /*
    3402             :          * Prevent a schema from being added to an extension if the schema
    3403             :          * contains the extension.  That would create a dependency loop.
    3404             :          */
    3405          98 :         if (object.classId == NamespaceRelationId &&
    3406           2 :             object.objectId == get_extension_schema(extension.objectId))
    3407           0 :             ereport(ERROR,
    3408             :                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    3409             :                      errmsg("cannot add schema \"%s\" to extension \"%s\" "
    3410             :                             "because the schema contains the extension",
    3411             :                             get_namespace_name(object.objectId),
    3412             :                             stmt->extname)));
    3413             : 
    3414             :         /*
    3415             :          * OK, add the dependency.
    3416             :          */
    3417          96 :         recordDependencyOn(&object, &extension, DEPENDENCY_EXTENSION);
    3418             : 
    3419             :         /*
    3420             :          * Also record the initial ACL on the object, if any.
    3421             :          *
    3422             :          * Note that this will handle the object's ACLs, as well as any ACLs
    3423             :          * on object subIds.  (In other words, when the object is a table,
    3424             :          * this will record the table's ACL and the ACLs for the columns on
    3425             :          * the table, if any).
    3426             :          */
    3427          96 :         recordExtObjInitPriv(object.objectId, object.classId);
    3428             :     }
    3429             :     else
    3430             :     {
    3431             :         /*
    3432             :          * DROP, so complain if it's not a member.
    3433             :          */
    3434         226 :         if (oldExtension != extension.objectId)
    3435           0 :             ereport(ERROR,
    3436             :                     (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
    3437             :                      errmsg("%s is not a member of extension \"%s\"",
    3438             :                             getObjectDescription(&object, false),
    3439             :                             stmt->extname)));
    3440             : 
    3441             :         /*
    3442             :          * OK, drop the dependency.
    3443             :          */
    3444         226 :         if (deleteDependencyRecordsForClass(object.classId, object.objectId,
    3445             :                                             ExtensionRelationId,
    3446             :                                             DEPENDENCY_EXTENSION) != 1)
    3447           0 :             elog(ERROR, "unexpected number of extension dependency records");
    3448             : 
    3449             :         /*
    3450             :          * If it's a relation, it might have an entry in the extension's
    3451             :          * extconfig array, which we must remove.
    3452             :          */
    3453         226 :         if (object.classId == RelationRelationId)
    3454          40 :             extension_config_remove(extension.objectId, object.objectId);
    3455             : 
    3456             :         /*
    3457             :          * Remove all the initial ACLs, if any.
    3458             :          *
    3459             :          * Note that this will remove the object's ACLs, as well as any ACLs
    3460             :          * on object subIds.  (In other words, when the object is a table,
    3461             :          * this will remove the table's ACL and the ACLs for the columns on
    3462             :          * the table, if any).
    3463             :          */
    3464         226 :         removeExtObjInitPriv(object.objectId, object.classId);
    3465             :     }
    3466             : 
    3467             :     /*
    3468             :      * Recurse to any dependent objects; currently, this includes the array
    3469             :      * type of a base type, the multirange type associated with a range type,
    3470             :      * and the rowtype of a table.
    3471             :      */
    3472         322 :     if (object.classId == TypeRelationId)
    3473             :     {
    3474             :         ObjectAddress depobject;
    3475             : 
    3476         132 :         depobject.classId = TypeRelationId;
    3477         132 :         depobject.objectSubId = 0;
    3478             : 
    3479             :         /* If it has an array type, update that too */
    3480         132 :         depobject.objectId = get_array_type(object.objectId);
    3481         132 :         if (OidIsValid(depobject.objectId))
    3482          66 :             ExecAlterExtensionContentsRecurse(stmt, extension, depobject);
    3483             : 
    3484             :         /* If it is a range type, update the associated multirange too */
    3485         132 :         if (type_is_range(object.objectId))
    3486             :         {
    3487           4 :             depobject.objectId = get_range_multirange(object.objectId);
    3488           4 :             if (!OidIsValid(depobject.objectId))
    3489           0 :                 ereport(ERROR,
    3490             :                         (errcode(ERRCODE_UNDEFINED_OBJECT),
    3491             :                          errmsg("could not find multirange type for data type %s",
    3492             :                                 format_type_be(object.objectId))));
    3493           4 :             ExecAlterExtensionContentsRecurse(stmt, extension, depobject);
    3494             :         }
    3495             :     }
    3496         322 :     if (object.classId == RelationRelationId)
    3497             :     {
    3498             :         ObjectAddress depobject;
    3499             : 
    3500          56 :         depobject.classId = TypeRelationId;
    3501          56 :         depobject.objectSubId = 0;
    3502             : 
    3503             :         /* It might not have a rowtype, but if it does, update that */
    3504          56 :         depobject.objectId = get_rel_type_id(object.objectId);
    3505          56 :         if (OidIsValid(depobject.objectId))
    3506          54 :             ExecAlterExtensionContentsRecurse(stmt, extension, depobject);
    3507             :     }
    3508         322 : }
    3509             : 
    3510             : /*
    3511             :  * Read the whole of file into memory.
    3512             :  *
    3513             :  * The file contents are returned as a single palloc'd chunk. For convenience
    3514             :  * of the callers, an extra \0 byte is added to the end.
    3515             :  */
    3516             : static char *
    3517         840 : read_whole_file(const char *filename, int *length)
    3518             : {
    3519             :     char       *buf;
    3520             :     FILE       *file;
    3521             :     size_t      bytes_to_read;
    3522             :     struct stat fst;
    3523             : 
    3524         840 :     if (stat(filename, &fst) < 0)
    3525           0 :         ereport(ERROR,
    3526             :                 (errcode_for_file_access(),
    3527             :                  errmsg("could not stat file \"%s\": %m", filename)));
    3528             : 
    3529         840 :     if (fst.st_size > (MaxAllocSize - 1))
    3530           0 :         ereport(ERROR,
    3531             :                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
    3532             :                  errmsg("file \"%s\" is too large", filename)));
    3533         840 :     bytes_to_read = (size_t) fst.st_size;
    3534             : 
    3535         840 :     if ((file = AllocateFile(filename, PG_BINARY_R)) == NULL)
    3536           0 :         ereport(ERROR,
    3537             :                 (errcode_for_file_access(),
    3538             :                  errmsg("could not open file \"%s\" for reading: %m",
    3539             :                         filename)));
    3540             : 
    3541         840 :     buf = (char *) palloc(bytes_to_read + 1);
    3542             : 
    3543         840 :     *length = fread(buf, 1, bytes_to_read, file);
    3544             : 
    3545         840 :     if (ferror(file))
    3546           0 :         ereport(ERROR,
    3547             :                 (errcode_for_file_access(),
    3548             :                  errmsg("could not read file \"%s\": %m", filename)));
    3549             : 
    3550         840 :     FreeFile(file);
    3551             : 
    3552         840 :     buf[*length] = '\0';
    3553         840 :     return buf;
    3554             : }

Generated by: LCOV version 1.14