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

Generated by: LCOV version 1.14