extension.c File Reference

#include "postgres.h"
#include <dirent.h>
#include <limits.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <unistd.h>
#include "access/genam.h"
#include "access/htup_details.h"
#include "access/relation.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "access/xact.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_database.h"
#include "catalog/pg_depend.h"
#include "catalog/pg_extension.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_type.h"
#include "commands/alter.h"
#include "commands/comment.h"
#include "commands/defrem.h"
#include "commands/extension.h"
#include "commands/schemacmds.h"
#include "funcapi.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "storage/fd.h"
#include "tcop/utility.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/conffiles.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
#include "utils/varlena.h"

Include dependency graph for extension.c:

Go to the source code of this file.

Data Structures
struct	ExtensionControlFile
struct	ExtensionVersionInfo

Typedefs
typedef struct ExtensionControlFile	ExtensionControlFile
typedef struct ExtensionVersionInfo	ExtensionVersionInfo

Functions
static List *	find_update_path (List *evi_list, ExtensionVersionInfo *evi_start, ExtensionVersionInfo *evi_target, bool reject_indirect, bool reinitialize)
static Oid	get_required_extension (char *reqExtensionName, char *extensionName, char *origSchemaName, bool cascade, List *parents, bool is_create)
static void	get_available_versions_for_extension (ExtensionControlFile *pcontrol, Tuplestorestate *tupstore, TupleDesc tupdesc)
static Datum	convert_requires_to_datum (List *requires)
static void	ApplyExtensionUpdates (Oid extensionOid, ExtensionControlFile *pcontrol, const char *initialVersion, List *updateVersions, char *origSchemaName, bool cascade, bool is_create)
static char *	read_whole_file (const char *filename, int *length)
Oid	get_extension_oid (const char *extname, bool missing_ok)
char *	get_extension_name (Oid ext_oid)
Oid	get_extension_schema (Oid ext_oid)
static void	check_valid_extension_name (const char *extensionname)
static void	check_valid_version_name (const char *versionname)
static bool	is_extension_control_filename (const char *filename)
static bool	is_extension_script_filename (const char *filename)
static char *	get_extension_control_directory (void)
static char *	get_extension_control_filename (const char *extname)
static char *	get_extension_script_directory (ExtensionControlFile *control)
static char *	get_extension_aux_control_filename (ExtensionControlFile *control, const char *version)
static char *	get_extension_script_filename (ExtensionControlFile *control, const char *from_version, const char *version)
static void	parse_extension_control_file (ExtensionControlFile *control, const char *version)
static ExtensionControlFile *	read_extension_control_file (const char *extname)
static ExtensionControlFile *	read_extension_aux_control_file (const ExtensionControlFile *pcontrol, const char *version)
static char *	read_extension_script_file (const ExtensionControlFile *control, const char *filename)
static void	execute_sql_string (const char *sql)
static bool	extension_is_trusted (ExtensionControlFile *control)
static void	execute_extension_script (Oid extensionOid, ExtensionControlFile *control, const char *from_version, const char *version, List *requiredSchemas, const char *schemaName, Oid schemaOid)
static ExtensionVersionInfo *	get_ext_ver_info (const char *versionname, List **evi_list)
static ExtensionVersionInfo *	get_nearest_unprocessed_vertex (List *evi_list)
static List *	get_ext_ver_list (ExtensionControlFile *control)
static List *	identify_update_path (ExtensionControlFile *control, const char *oldVersion, const char *newVersion)
static ExtensionVersionInfo *	find_install_path (List *evi_list, ExtensionVersionInfo *evi_target, List **best_path)
static ObjectAddress	CreateExtensionInternal (char *extensionName, char *schemaName, const char *versionName, bool cascade, List *parents, bool is_create)
ObjectAddress	CreateExtension (ParseState *pstate, CreateExtensionStmt *stmt)
ObjectAddress	InsertExtensionTuple (const char *extName, Oid extOwner, Oid schemaOid, bool relocatable, const char *extVersion, Datum extConfig, Datum extCondition, List *requiredExtensions)
void	RemoveExtensionById (Oid extId)
Datum	pg_available_extensions (PG_FUNCTION_ARGS)
Datum	pg_available_extension_versions (PG_FUNCTION_ARGS)
bool	extension_file_exists (const char *extensionName)
Datum	pg_extension_update_paths (PG_FUNCTION_ARGS)
Datum	pg_extension_config_dump (PG_FUNCTION_ARGS)
static void	extension_config_remove (Oid extensionoid, Oid tableoid)
ObjectAddress	AlterExtensionNamespace (const char *extensionName, const char *newschema, Oid *oldschema)
ObjectAddress	ExecAlterExtensionStmt (ParseState *pstate, AlterExtensionStmt *stmt)
ObjectAddress	ExecAlterExtensionContentsStmt (AlterExtensionContentsStmt *stmt, ObjectAddress *objAddr)

Variables
bool	creating_extension = false
Oid	CurrentExtensionObject = InvalidOid

Typedef Documentation

ExtensionControlFile

typedef struct ExtensionControlFile ExtensionControlFile

ExtensionVersionInfo

typedef struct ExtensionVersionInfo ExtensionVersionInfo

Function Documentation

AlterExtensionNamespace()

ObjectAddress AlterExtensionNamespace	(	const char *	extensionName,
		const char *	newschema,
		Oid *	oldschema
	)

Definition at line 2749 of file extension.c.

{
    Oid         extensionOid;
    Oid         nspOid;
    Oid         oldNspOid = InvalidOid;
    AclResult   aclresult;
    Relation    extRel;
    ScanKeyData key[2];
    SysScanDesc extScan;
    HeapTuple   extTup;
    Form_pg_extension extForm;
    Relation    depRel;
    SysScanDesc depScan;
    HeapTuple   depTup;
    ObjectAddresses *objsMoved;
    ObjectAddress extAddr;
 
    extensionOid = get_extension_oid(extensionName, false);
 
    nspOid = LookupCreationNamespace(newschema);
 
    /*
     * Permission check: must own extension.  Note that we don't bother to
     * check ownership of the individual member objects ...
     */
    if (!object_ownercheck(ExtensionRelationId, extensionOid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EXTENSION,
                       extensionName);
 
    /* Permission check: must have creation rights in target namespace */
    aclresult = object_aclcheck(NamespaceRelationId, nspOid, GetUserId(), ACL_CREATE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_SCHEMA, newschema);
 
    /*
     * If the schema is currently a member of the extension, disallow moving
     * the extension into the schema.  That would create a dependency loop.
     */
    if (getExtensionOfObject(NamespaceRelationId, nspOid) == extensionOid)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("cannot move extension \"%s\" into schema \"%s\" "
                        "because the extension contains the schema",
                        extensionName, newschema)));
 
    /* Locate the pg_extension tuple */
    extRel = table_open(ExtensionRelationId, RowExclusiveLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_extension_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(extensionOid));
 
    extScan = systable_beginscan(extRel, ExtensionOidIndexId, true,
                                 NULL, 1, key);
 
    extTup = systable_getnext(extScan);
 
    if (!HeapTupleIsValid(extTup))  /* should not happen */
        elog(ERROR, "could not find tuple for extension %u",
             extensionOid);
 
    /* Copy tuple so we can modify it below */
    extTup = heap_copytuple(extTup);
    extForm = (Form_pg_extension) GETSTRUCT(extTup);
 
    systable_endscan(extScan);
 
    /*
     * If the extension is already in the target schema, just silently do
     * nothing.
     */
    if (extForm->extnamespace == nspOid)
    {
        table_close(extRel, RowExclusiveLock);
        return InvalidObjectAddress;
    }
 
    /* Check extension is supposed to be relocatable */
    if (!extForm->extrelocatable)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("extension \"%s\" does not support SET SCHEMA",
                        NameStr(extForm->extname))));
 
    objsMoved = new_object_addresses();
 
    /*
     * Scan pg_depend to find objects that depend directly on the extension,
     * and alter each one's schema.
     */
    depRel = table_open(DependRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_depend_refclassid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(ExtensionRelationId));
    ScanKeyInit(&key[1],
                Anum_pg_depend_refobjid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(extensionOid));
 
    depScan = systable_beginscan(depRel, DependReferenceIndexId, true,
                                 NULL, 2, key);
 
    while (HeapTupleIsValid(depTup = systable_getnext(depScan)))
    {
        Form_pg_depend pg_depend = (Form_pg_depend) GETSTRUCT(depTup);
        ObjectAddress dep;
        Oid         dep_oldNspOid;
 
        /*
         * If a dependent extension has a no_relocate request for this
         * extension, disallow SET SCHEMA.  (XXX it's a bit ugly to do this in
         * the same loop that's actually executing the renames: we may detect
         * the error condition only after having expended a fair amount of
         * work.  However, the alternative is to do two scans of pg_depend,
         * which seems like optimizing for failure cases.  The rename work
         * will all roll back cleanly enough if we do fail here.)
         */
        if (pg_depend->deptype == DEPENDENCY_NORMAL &&
            pg_depend->classid == ExtensionRelationId)
        {
            char       *depextname = get_extension_name(pg_depend->objid);
            ExtensionControlFile *dcontrol;
            ListCell   *lc;
 
            dcontrol = read_extension_control_file(depextname);
            foreach(lc, dcontrol->no_relocate)
            {
                char       *nrextname = (char *) lfirst(lc);
 
                if (strcmp(nrextname, NameStr(extForm->extname)) == 0)
                {
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("cannot SET SCHEMA of extension \"%s\" because other extensions prevent it",
                                    NameStr(extForm->extname)),
                             errdetail("Extension \"%s\" requests no relocation of extension \"%s\".",
                                       depextname,
                                       NameStr(extForm->extname))));
                }
            }
        }
 
        /*
         * Otherwise, ignore non-membership dependencies.  (Currently, the
         * only other case we could see here is a normal dependency from
         * another extension.)
         */
        if (pg_depend->deptype != DEPENDENCY_EXTENSION)
            continue;
 
        dep.classId = pg_depend->classid;
        dep.objectId = pg_depend->objid;
        dep.objectSubId = pg_depend->objsubid;
 
        if (dep.objectSubId != 0)   /* should not happen */
            elog(ERROR, "extension should not have a sub-object dependency");
 
        /* Relocate the object */
        dep_oldNspOid = AlterObjectNamespace_oid(dep.classId,
                                                 dep.objectId,
                                                 nspOid,
                                                 objsMoved);
 
        /*
         * Remember previous namespace of first object that has one
         */
        if (oldNspOid == InvalidOid && dep_oldNspOid != InvalidOid)
            oldNspOid = dep_oldNspOid;
 
        /*
         * If not all the objects had the same old namespace (ignoring any
         * that are not in namespaces), complain.
         */
        if (dep_oldNspOid != InvalidOid && dep_oldNspOid != oldNspOid)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("extension \"%s\" does not support SET SCHEMA",
                            NameStr(extForm->extname)),
                     errdetail("%s is not in the extension's schema \"%s\"",
                               getObjectDescription(&dep, false),
                               get_namespace_name(oldNspOid))));
    }
 
    /* report old schema, if caller wants it */
    if (oldschema)
        *oldschema = oldNspOid;
 
    systable_endscan(depScan);
 
    relation_close(depRel, AccessShareLock);
 
    /* Now adjust pg_extension.extnamespace */
    extForm->extnamespace = nspOid;
 
    CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
 
    table_close(extRel, RowExclusiveLock);
 
    /* update dependencies to point to the new schema */
    changeDependencyFor(ExtensionRelationId, extensionOid,
                        NamespaceRelationId, oldNspOid, nspOid);
 
    InvokeObjectPostAlterHook(ExtensionRelationId, extensionOid, 0);
 
    ObjectAddressSet(extAddr, ExtensionRelationId, extensionOid);
 
    return extAddr;
}

References AccessShareLock, ACL_CREATE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, AlterObjectNamespace_oid(), BTEqualStrategyNumber, CatalogTupleUpdate(), changeDependencyFor(), ObjectAddress::classId, DEPENDENCY_EXTENSION, DEPENDENCY_NORMAL, elog(), ereport, errcode(), errdetail(), errmsg(), ERROR, get_extension_name(), get_extension_oid(), get_namespace_name(), getExtensionOfObject(), getObjectDescription(), GETSTRUCT, GetUserId(), heap_copytuple(), HeapTupleIsValid, InvalidObjectAddress, InvalidOid, InvokeObjectPostAlterHook, sort-test::key, lfirst, LookupCreationNamespace(), NameStr, new_object_addresses(), ExtensionControlFile::no_relocate, object_aclcheck(), OBJECT_EXTENSION, object_ownercheck(), OBJECT_SCHEMA, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, read_extension_control_file(), relation_close(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ExecAlterObjectSchemaStmt().

ApplyExtensionUpdates()

static void ApplyExtensionUpdates ( Oid  extensionOid, ExtensionControlFile *  pcontrol, const char *  initialVersion, List *  updateVersions, char *  origSchemaName, bool  cascade, bool  is_create  )

static

Definition at line 3112 of file extension.c.

{
    const char *oldVersionName = initialVersion;
    ListCell   *lcv;
 
    foreach(lcv, updateVersions)
    {
        char       *versionName = (char *) lfirst(lcv);
        ExtensionControlFile *control;
        char       *schemaName;
        Oid         schemaOid;
        List       *requiredExtensions;
        List       *requiredSchemas;
        Relation    extRel;
        ScanKeyData key[1];
        SysScanDesc extScan;
        HeapTuple   extTup;
        Form_pg_extension extForm;
        Datum       values[Natts_pg_extension];
        bool        nulls[Natts_pg_extension];
        bool        repl[Natts_pg_extension];
        ObjectAddress myself;
        ListCell   *lc;
 
        /*
         * Fetch parameters for specific version (pcontrol is not changed)
         */
        control = read_extension_aux_control_file(pcontrol, versionName);
 
        /* Find the pg_extension tuple */
        extRel = table_open(ExtensionRelationId, RowExclusiveLock);
 
        ScanKeyInit(&key[0],
                    Anum_pg_extension_oid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(extensionOid));
 
        extScan = systable_beginscan(extRel, ExtensionOidIndexId, true,
                                     NULL, 1, key);
 
        extTup = systable_getnext(extScan);
 
        if (!HeapTupleIsValid(extTup))  /* should not happen */
            elog(ERROR, "could not find tuple for extension %u",
                 extensionOid);
 
        extForm = (Form_pg_extension) GETSTRUCT(extTup);
 
        /*
         * Determine the target schema (set by original install)
         */
        schemaOid = extForm->extnamespace;
        schemaName = get_namespace_name(schemaOid);
 
        /*
         * Modify extrelocatable and extversion in the pg_extension tuple
         */
        memset(values, 0, sizeof(values));
        memset(nulls, 0, sizeof(nulls));
        memset(repl, 0, sizeof(repl));
 
        values[Anum_pg_extension_extrelocatable - 1] =
            BoolGetDatum(control->relocatable);
        repl[Anum_pg_extension_extrelocatable - 1] = true;
        values[Anum_pg_extension_extversion - 1] =
            CStringGetTextDatum(versionName);
        repl[Anum_pg_extension_extversion - 1] = true;
 
        extTup = heap_modify_tuple(extTup, RelationGetDescr(extRel),
                                   values, nulls, repl);
 
        CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
 
        systable_endscan(extScan);
 
        table_close(extRel, RowExclusiveLock);
 
        /*
         * Look up the prerequisite extensions for this version, install them
         * if necessary, and build lists of their OIDs and the OIDs of their
         * target schemas.
         */
        requiredExtensions = NIL;
        requiredSchemas = NIL;
        foreach(lc, control->requires)
        {
            char       *curreq = (char *) lfirst(lc);
            Oid         reqext;
            Oid         reqschema;
 
            reqext = get_required_extension(curreq,
                                            control->name,
                                            origSchemaName,
                                            cascade,
                                            NIL,
                                            is_create);
            reqschema = get_extension_schema(reqext);
            requiredExtensions = lappend_oid(requiredExtensions, reqext);
            requiredSchemas = lappend_oid(requiredSchemas, reqschema);
        }
 
        /*
         * Remove and recreate dependencies on prerequisite extensions
         */
        deleteDependencyRecordsForClass(ExtensionRelationId, extensionOid,
                                        ExtensionRelationId,
                                        DEPENDENCY_NORMAL);
 
        myself.classId = ExtensionRelationId;
        myself.objectId = extensionOid;
        myself.objectSubId = 0;
 
        foreach(lc, requiredExtensions)
        {
            Oid         reqext = lfirst_oid(lc);
            ObjectAddress otherext;
 
            otherext.classId = ExtensionRelationId;
            otherext.objectId = reqext;
            otherext.objectSubId = 0;
 
            recordDependencyOn(&myself, &otherext, DEPENDENCY_NORMAL);
        }
 
        InvokeObjectPostAlterHook(ExtensionRelationId, extensionOid, 0);
 
        /*
         * Finally, execute the update script file
         */
        execute_extension_script(extensionOid, control,
                                 oldVersionName, versionName,
                                 requiredSchemas,
                                 schemaName, schemaOid);
 
        /*
         * Update prior-version name and loop around.  Since
         * execute_sql_string did a final CommandCounterIncrement, we can
         * update the pg_extension row again.
         */
        oldVersionName = versionName;
    }
}

References BoolGetDatum(), BTEqualStrategyNumber, CatalogTupleUpdate(), ObjectAddress::classId, CStringGetTextDatum, deleteDependencyRecordsForClass(), DEPENDENCY_NORMAL, elog(), ERROR, execute_extension_script(), get_extension_schema(), get_namespace_name(), get_required_extension(), GETSTRUCT, heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, sort-test::key, lappend_oid(), lfirst, lfirst_oid, ExtensionControlFile::name, NIL, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, read_extension_aux_control_file(), recordDependencyOn(), RelationGetDescr, ExtensionControlFile::relocatable, ExtensionControlFile::requires, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), table_open(), and values.

Referenced by CreateExtensionInternal(), and ExecAlterExtensionStmt().

check_valid_extension_name()

static void check_valid_extension_name ( const char *  extensionname )

static

Definition at line 265 of file extension.c.

{
    int         namelen = strlen(extensionname);
 
    /*
     * Disallow empty names (the parser rejects empty identifiers anyway, but
     * let's check).
     */
    if (namelen == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid extension name: \"%s\"", extensionname),
                 errdetail("Extension names must not be empty.")));
 
    /*
     * No double dashes, since that would make script filenames ambiguous.
     */
    if (strstr(extensionname, "--"))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid extension name: \"%s\"", extensionname),
                 errdetail("Extension names must not contain \"--\".")));
 
    /*
     * No leading or trailing dash either.  (We could probably allow this, but
     * it would require much care in filename parsing and would make filenames
     * visually if not formally ambiguous.  Since there's no real-world use
     * case, let's just forbid it.)
     */
    if (extensionname[0] == '-' || extensionname[namelen - 1] == '-')
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid extension name: \"%s\"", extensionname),
                 errdetail("Extension names must not begin or end with \"-\".")));
 
    /*
     * No directory separators either (this is sufficient to prevent ".."
     * style attacks).
     */
    if (first_dir_separator(extensionname) != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid extension name: \"%s\"", extensionname),
                 errdetail("Extension names must not contain directory separator characters.")));
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, and first_dir_separator().

Referenced by CreateExtension(), get_required_extension(), and pg_extension_update_paths().

check_valid_version_name()

static void check_valid_version_name ( const char *  versionname )

static

Definition at line 312 of file extension.c.

{
    int         namelen = strlen(versionname);
 
    /*
     * Disallow empty names (we could possibly allow this, but there seems
     * little point).
     */
    if (namelen == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid extension version name: \"%s\"", versionname),
                 errdetail("Version names must not be empty.")));
 
    /*
     * No double dashes, since that would make script filenames ambiguous.
     */
    if (strstr(versionname, "--"))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid extension version name: \"%s\"", versionname),
                 errdetail("Version names must not contain \"--\".")));
 
    /*
     * No leading or trailing dash either.
     */
    if (versionname[0] == '-' || versionname[namelen - 1] == '-')
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid extension version name: \"%s\"", versionname),
                 errdetail("Version names must not begin or end with \"-\".")));
 
    /*
     * No directory separators either (this is sufficient to prevent ".."
     * style attacks).
     */
    if (first_dir_separator(versionname) != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid extension version name: \"%s\"", versionname),
                 errdetail("Version names must not contain directory separator characters.")));
}

References ereport, errcode(), errdetail(), errmsg(), ERROR, and first_dir_separator().

Referenced by CreateExtensionInternal(), and ExecAlterExtensionStmt().

convert_requires_to_datum()

static Datum convert_requires_to_datum ( List *  requires )

static

Definition at line 2290 of file extension.c.

{
    Datum      *datums;
    int         ndatums;
    ArrayType  *a;
    ListCell   *lc;
 
    ndatums = list_length(requires);
    datums = (Datum *) palloc(ndatums * sizeof(Datum));
    ndatums = 0;
    foreach(lc, requires)
    {
        char       *curreq = (char *) lfirst(lc);
 
        datums[ndatums++] =
            DirectFunctionCall1(namein, CStringGetDatum(curreq));
    }
    a = construct_array_builtin(datums, ndatums, NAMEOID);
    return PointerGetDatum(a);
}

References a, construct_array_builtin(), CStringGetDatum(), DirectFunctionCall1, lfirst, list_length(), namein(), palloc(), and PointerGetDatum().

Referenced by get_available_versions_for_extension().

CreateExtension()

ObjectAddress CreateExtension	(	ParseState *	pstate,
		CreateExtensionStmt *	stmt
	)

Definition at line 1745 of file extension.c.

{
    DefElem    *d_schema = NULL;
    DefElem    *d_new_version = NULL;
    DefElem    *d_cascade = NULL;
    char       *schemaName = NULL;
    char       *versionName = NULL;
    bool        cascade = false;
    ListCell   *lc;
 
    /* Check extension name validity before any filesystem access */
    check_valid_extension_name(stmt->extname);
 
    /*
     * Check for duplicate extension name.  The unique index on
     * pg_extension.extname would catch this anyway, and serves as a backstop
     * in case of race conditions; but this is a friendlier error message, and
     * besides we need a check to support IF NOT EXISTS.
     */
    if (get_extension_oid(stmt->extname, true) != InvalidOid)
    {
        if (stmt->if_not_exists)
        {
            ereport(NOTICE,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("extension \"%s\" already exists, skipping",
                            stmt->extname)));
            return InvalidObjectAddress;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("extension \"%s\" already exists",
                            stmt->extname)));
    }
 
    /*
     * We use global variables to track the extension being created, so we can
     * create only one extension at the same time.
     */
    if (creating_extension)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("nested CREATE EXTENSION is not supported")));
 
    /* Deconstruct the statement option list */
    foreach(lc, stmt->options)
    {
        DefElem    *defel = (DefElem *) lfirst(lc);
 
        if (strcmp(defel->defname, "schema") == 0)
        {
            if (d_schema)
                errorConflictingDefElem(defel, pstate);
            d_schema = defel;
            schemaName = defGetString(d_schema);
        }
        else if (strcmp(defel->defname, "new_version") == 0)
        {
            if (d_new_version)
                errorConflictingDefElem(defel, pstate);
            d_new_version = defel;
            versionName = defGetString(d_new_version);
        }
        else if (strcmp(defel->defname, "cascade") == 0)
        {
            if (d_cascade)
                errorConflictingDefElem(defel, pstate);
            d_cascade = defel;
            cascade = defGetBoolean(d_cascade);
        }
        else
            elog(ERROR, "unrecognized option: %s", defel->defname);
    }
 
    /* Call CreateExtensionInternal to do the real work. */
    return CreateExtensionInternal(stmt->extname,
                                   schemaName,
                                   versionName,
                                   cascade,
                                   NIL,
                                   true);
}

References check_valid_extension_name(), CreateExtensionInternal(), creating_extension, defGetBoolean(), defGetString(), DefElem::defname, elog(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, errorConflictingDefElem(), get_extension_oid(), InvalidObjectAddress, InvalidOid, lfirst, NIL, NOTICE, and stmt.

Referenced by ProcessUtilitySlow().

CreateExtensionInternal()

static ObjectAddress CreateExtensionInternal ( char *  extensionName, char *  schemaName, const char *  versionName, bool  cascade, List *  parents, bool  is_create  )

static

Definition at line 1435 of file extension.c.

{
    char       *origSchemaName = schemaName;
    Oid         schemaOid = InvalidOid;
    Oid         extowner = GetUserId();
    ExtensionControlFile *pcontrol;
    ExtensionControlFile *control;
    char       *filename;
    struct stat fst;
    List       *updateVersions;
    List       *requiredExtensions;
    List       *requiredSchemas;
    Oid         extensionOid;
    ObjectAddress address;
    ListCell   *lc;
 
    /*
     * Read the primary control file.  Note we assume that it does not contain
     * any non-ASCII data, so there is no need to worry about encoding at this
     * point.
     */
    pcontrol = read_extension_control_file(extensionName);
 
    /*
     * Determine the version to install
     */
    if (versionName == NULL)
    {
        if (pcontrol->default_version)
            versionName = pcontrol->default_version;
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("version to install must be specified")));
    }
    check_valid_version_name(versionName);
 
    /*
     * Figure out which script(s) we need to run to install the desired
     * version of the extension.  If we do not have a script that directly
     * does what is needed, we try to find a sequence of update scripts that
     * will get us there.
     */
    filename = get_extension_script_filename(pcontrol, NULL, versionName);
    if (stat(filename, &fst) == 0)
    {
        /* Easy, no extra scripts */
        updateVersions = NIL;
    }
    else
    {
        /* Look for best way to install this version */
        List       *evi_list;
        ExtensionVersionInfo *evi_start;
        ExtensionVersionInfo *evi_target;
 
        /* Extract the version update graph from the script directory */
        evi_list = get_ext_ver_list(pcontrol);
 
        /* Identify the target version */
        evi_target = get_ext_ver_info(versionName, &evi_list);
 
        /* Identify best path to reach target */
        evi_start = find_install_path(evi_list, evi_target,
                                      &updateVersions);
 
        /* Fail if no path ... */
        if (evi_start == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("extension \"%s\" has no installation script nor update path for version \"%s\"",
                            pcontrol->name, versionName)));
 
        /* Otherwise, install best starting point and then upgrade */
        versionName = evi_start->name;
    }
 
    /*
     * Fetch control parameters for installation target version
     */
    control = read_extension_aux_control_file(pcontrol, versionName);
 
    /*
     * Determine the target schema to install the extension into
     */
    if (schemaName)
    {
        /* If the user is giving us the schema name, it must exist already. */
        schemaOid = get_namespace_oid(schemaName, false);
    }
 
    if (control->schema != NULL)
    {
        /*
         * The extension is not relocatable and the author gave us a schema
         * for it.
         *
         * Unless CASCADE parameter was given, it's an error to give a schema
         * different from control->schema if control->schema is specified.
         */
        if (schemaName && strcmp(control->schema, schemaName) != 0 &&
            !cascade)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("extension \"%s\" must be installed in schema \"%s\"",
                            control->name,
                            control->schema)));
 
        /* Always use the schema from control file for current extension. */
        schemaName = control->schema;
 
        /* Find or create the schema in case it does not exist. */
        schemaOid = get_namespace_oid(schemaName, true);
 
        if (!OidIsValid(schemaOid))
        {
            CreateSchemaStmt *csstmt = makeNode(CreateSchemaStmt);
 
            csstmt->schemaname = schemaName;
            csstmt->authrole = NULL;    /* will be created by current user */
            csstmt->schemaElts = NIL;
            csstmt->if_not_exists = false;
            CreateSchemaCommand(csstmt, "(generated CREATE SCHEMA command)",
                                -1, -1);
 
            /*
             * CreateSchemaCommand includes CommandCounterIncrement, so new
             * schema is now visible.
             */
            schemaOid = get_namespace_oid(schemaName, false);
        }
    }
    else if (!OidIsValid(schemaOid))
    {
        /*
         * Neither user nor author of the extension specified schema; use the
         * current default creation namespace, which is the first explicit
         * entry in the search_path.
         */
        List       *search_path = fetch_search_path(false);
 
        if (search_path == NIL) /* nothing valid in search_path? */
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_SCHEMA),
                     errmsg("no schema has been selected to create in")));
        schemaOid = linitial_oid(search_path);
        schemaName = get_namespace_name(schemaOid);
        if (schemaName == NULL) /* recently-deleted namespace? */
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_SCHEMA),
                     errmsg("no schema has been selected to create in")));
 
        list_free(search_path);
    }
 
    /*
     * Make note if a temporary namespace has been accessed in this
     * transaction.
     */
    if (isTempNamespace(schemaOid))
        MyXactFlags |= XACT_FLAGS_ACCESSEDTEMPNAMESPACE;
 
    /*
     * We don't check creation rights on the target namespace here.  If the
     * extension script actually creates any objects there, it will fail if
     * the user doesn't have such permissions.  But there are cases such as
     * procedural languages where it's convenient to set schema = pg_catalog
     * yet we don't want to restrict the command to users with ACL_CREATE for
     * pg_catalog.
     */
 
    /*
     * Look up the prerequisite extensions, install them if necessary, and
     * build lists of their OIDs and the OIDs of their target schemas.
     */
    requiredExtensions = NIL;
    requiredSchemas = NIL;
    foreach(lc, control->requires)
    {
        char       *curreq = (char *) lfirst(lc);
        Oid         reqext;
        Oid         reqschema;
 
        reqext = get_required_extension(curreq,
                                        extensionName,
                                        origSchemaName,
                                        cascade,
                                        parents,
                                        is_create);
        reqschema = get_extension_schema(reqext);
        requiredExtensions = lappend_oid(requiredExtensions, reqext);
        requiredSchemas = lappend_oid(requiredSchemas, reqschema);
    }
 
    /*
     * Insert new tuple into pg_extension, and create dependency entries.
     */
    address = InsertExtensionTuple(control->name, extowner,
                                   schemaOid, control->relocatable,
                                   versionName,
                                   PointerGetDatum(NULL),
                                   PointerGetDatum(NULL),
                                   requiredExtensions);
    extensionOid = address.objectId;
 
    /*
     * Apply any control-file comment on extension
     */
    if (control->comment != NULL)
        CreateComments(extensionOid, ExtensionRelationId, 0, control->comment);
 
    /*
     * Execute the installation script file
     */
    execute_extension_script(extensionOid, control,
                             NULL, versionName,
                             requiredSchemas,
                             schemaName, schemaOid);
 
    /*
     * If additional update scripts have to be executed, apply the updates as
     * though a series of ALTER EXTENSION UPDATE commands were given
     */
    ApplyExtensionUpdates(extensionOid, pcontrol,
                          versionName, updateVersions,
                          origSchemaName, cascade, is_create);
 
    return address;
}

References ApplyExtensionUpdates(), CreateSchemaStmt::authrole, check_valid_version_name(), ExtensionControlFile::comment, CreateComments(), CreateSchemaCommand(), ExtensionControlFile::default_version, ereport, errcode(), errmsg(), ERROR, execute_extension_script(), fetch_search_path(), filename, find_install_path(), get_ext_ver_info(), get_ext_ver_list(), get_extension_schema(), get_extension_script_filename(), get_namespace_name(), get_namespace_oid(), get_required_extension(), GetUserId(), CreateSchemaStmt::if_not_exists, InsertExtensionTuple(), InvalidOid, isTempNamespace(), lappend_oid(), lfirst, linitial_oid, list_free(), makeNode, MyXactFlags, ExtensionControlFile::name, ExtensionVersionInfo::name, NIL, ObjectAddress::objectId, OidIsValid, PointerGetDatum(), read_extension_aux_control_file(), read_extension_control_file(), ExtensionControlFile::relocatable, ExtensionControlFile::requires, ExtensionControlFile::schema, CreateSchemaStmt::schemaElts, CreateSchemaStmt::schemaname, stat, and XACT_FLAGS_ACCESSEDTEMPNAMESPACE.

Referenced by CreateExtension(), and get_required_extension().

ExecAlterExtensionContentsStmt()

ObjectAddress ExecAlterExtensionContentsStmt	(	AlterExtensionContentsStmt *	stmt,
		ObjectAddress *	objAddr
	)

Definition at line 3270 of file extension.c.

{
    ObjectAddress extension;
    ObjectAddress object;
    Relation    relation;
    Oid         oldExtension;
 
    switch (stmt->objtype)
    {
        case OBJECT_DATABASE:
        case OBJECT_EXTENSION:
        case OBJECT_INDEX:
        case OBJECT_PUBLICATION:
        case OBJECT_ROLE:
        case OBJECT_STATISTIC_EXT:
        case OBJECT_SUBSCRIPTION:
        case OBJECT_TABLESPACE:
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("cannot add an object of this type to an extension")));
            break;
        default:
            /* OK */
            break;
    }
 
    /*
     * Find the extension and acquire a lock on it, to ensure it doesn't get
     * dropped concurrently.  A sharable lock seems sufficient: there's no
     * reason not to allow other sorts of manipulations, such as add/drop of
     * other objects, to occur concurrently.  Concurrently adding/dropping the
     * *same* object would be bad, but we prevent that by using a non-sharable
     * lock on the individual object, below.
     */
    extension = get_object_address(OBJECT_EXTENSION,
                                   (Node *) makeString(stmt->extname),
                                   &relation, AccessShareLock, false);
 
    /* Permission check: must own extension */
    if (!object_ownercheck(ExtensionRelationId, extension.objectId, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EXTENSION,
                       stmt->extname);
 
    /*
     * Translate the parser representation that identifies the object into an
     * ObjectAddress.  get_object_address() will throw an error if the object
     * does not exist, and will also acquire a lock on the object to guard
     * against concurrent DROP and ALTER EXTENSION ADD/DROP operations.
     */
    object = get_object_address(stmt->objtype, stmt->object,
                                &relation, ShareUpdateExclusiveLock, false);
 
    Assert(object.objectSubId == 0);
    if (objAddr)
        *objAddr = object;
 
    /* Permission check: must own target object, too */
    check_object_ownership(GetUserId(), stmt->objtype, object,
                           stmt->object, relation);
 
    /*
     * Check existing extension membership.
     */
    oldExtension = getExtensionOfObject(object.classId, object.objectId);
 
    if (stmt->action > 0)
    {
        /*
         * ADD, so complain if object is already attached to some extension.
         */
        if (OidIsValid(oldExtension))
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("%s is already a member of extension \"%s\"",
                            getObjectDescription(&object, false),
                            get_extension_name(oldExtension))));
 
        /*
         * Prevent a schema from being added to an extension if the schema
         * contains the extension.  That would create a dependency loop.
         */
        if (object.classId == NamespaceRelationId &&
            object.objectId == get_extension_schema(extension.objectId))
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("cannot add schema \"%s\" to extension \"%s\" "
                            "because the schema contains the extension",
                            get_namespace_name(object.objectId),
                            stmt->extname)));
 
        /*
         * OK, add the dependency.
         */
        recordDependencyOn(&object, &extension, DEPENDENCY_EXTENSION);
 
        /*
         * Also record the initial ACL on the object, if any.
         *
         * Note that this will handle the object's ACLs, as well as any ACLs
         * on object subIds.  (In other words, when the object is a table,
         * this will record the table's ACL and the ACLs for the columns on
         * the table, if any).
         */
        recordExtObjInitPriv(object.objectId, object.classId);
    }
    else
    {
        /*
         * DROP, so complain if it's not a member.
         */
        if (oldExtension != extension.objectId)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("%s is not a member of extension \"%s\"",
                            getObjectDescription(&object, false),
                            stmt->extname)));
 
        /*
         * OK, drop the dependency.
         */
        if (deleteDependencyRecordsForClass(object.classId, object.objectId,
                                            ExtensionRelationId,
                                            DEPENDENCY_EXTENSION) != 1)
            elog(ERROR, "unexpected number of extension dependency records");
 
        /*
         * If it's a relation, it might have an entry in the extension's
         * extconfig array, which we must remove.
         */
        if (object.classId == RelationRelationId)
            extension_config_remove(extension.objectId, object.objectId);
 
        /*
         * Remove all the initial ACLs, if any.
         *
         * Note that this will remove the object's ACLs, as well as any ACLs
         * on object subIds.  (In other words, when the object is a table,
         * this will remove the table's ACL and the ACLs for the columns on
         * the table, if any).
         */
        removeExtObjInitPriv(object.objectId, object.classId);
    }
 
    InvokeObjectPostAlterHook(ExtensionRelationId, extension.objectId, 0);
 
    /*
     * If get_object_address() opened the relation for us, we close it to keep
     * the reference count correct - but we retain any locks acquired by
     * get_object_address() until commit time, to guard against concurrent
     * activity.
     */
    if (relation != NULL)
        relation_close(relation, NoLock);
 
    return extension;
}

References AccessShareLock, aclcheck_error(), ACLCHECK_NOT_OWNER, Assert(), check_object_ownership(), deleteDependencyRecordsForClass(), DEPENDENCY_EXTENSION, elog(), ereport, errcode(), errmsg(), ERROR, extension_config_remove(), get_extension_name(), get_extension_schema(), get_namespace_name(), get_object_address(), getExtensionOfObject(), getObjectDescription(), GetUserId(), InvokeObjectPostAlterHook, makeString(), NoLock, OBJECT_DATABASE, OBJECT_EXTENSION, OBJECT_INDEX, object_ownercheck(), OBJECT_PUBLICATION, OBJECT_ROLE, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABLESPACE, ObjectAddress::objectId, OidIsValid, recordDependencyOn(), recordExtObjInitPriv(), relation_close(), removeExtObjInitPriv(), ShareUpdateExclusiveLock, and stmt.

Referenced by ProcessUtilitySlow().

ExecAlterExtensionStmt()

ObjectAddress ExecAlterExtensionStmt	(	ParseState *	pstate,
		AlterExtensionStmt *	stmt
	)

Definition at line 2965 of file extension.c.

{
    DefElem    *d_new_version = NULL;
    char       *versionName;
    char       *oldVersionName;
    ExtensionControlFile *control;
    Oid         extensionOid;
    Relation    extRel;
    ScanKeyData key[1];
    SysScanDesc extScan;
    HeapTuple   extTup;
    List       *updateVersions;
    Datum       datum;
    bool        isnull;
    ListCell   *lc;
    ObjectAddress address;
 
    /*
     * We use global variables to track the extension being created, so we can
     * create/update only one extension at the same time.
     */
    if (creating_extension)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("nested ALTER EXTENSION is not supported")));
 
    /*
     * Look up the extension --- it must already exist in pg_extension
     */
    extRel = table_open(ExtensionRelationId, AccessShareLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_extension_extname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(stmt->extname));
 
    extScan = systable_beginscan(extRel, ExtensionNameIndexId, true,
                                 NULL, 1, key);
 
    extTup = systable_getnext(extScan);
 
    if (!HeapTupleIsValid(extTup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("extension \"%s\" does not exist",
                        stmt->extname)));
 
    extensionOid = ((Form_pg_extension) GETSTRUCT(extTup))->oid;
 
    /*
     * Determine the existing version we are updating from
     */
    datum = heap_getattr(extTup, Anum_pg_extension_extversion,
                         RelationGetDescr(extRel), &isnull);
    if (isnull)
        elog(ERROR, "extversion is null");
    oldVersionName = text_to_cstring(DatumGetTextPP(datum));
 
    systable_endscan(extScan);
 
    table_close(extRel, AccessShareLock);
 
    /* Permission check: must own extension */
    if (!object_ownercheck(ExtensionRelationId, extensionOid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EXTENSION,
                       stmt->extname);
 
    /*
     * Read the primary control file.  Note we assume that it does not contain
     * any non-ASCII data, so there is no need to worry about encoding at this
     * point.
     */
    control = read_extension_control_file(stmt->extname);
 
    /*
     * Read the statement option list
     */
    foreach(lc, stmt->options)
    {
        DefElem    *defel = (DefElem *) lfirst(lc);
 
        if (strcmp(defel->defname, "new_version") == 0)
        {
            if (d_new_version)
                errorConflictingDefElem(defel, pstate);
            d_new_version = defel;
        }
        else
            elog(ERROR, "unrecognized option: %s", defel->defname);
    }
 
    /*
     * Determine the version to update to
     */
    if (d_new_version && d_new_version->arg)
        versionName = strVal(d_new_version->arg);
    else if (control->default_version)
        versionName = control->default_version;
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("version to install must be specified")));
        versionName = NULL;     /* keep compiler quiet */
    }
    check_valid_version_name(versionName);
 
    /*
     * If we're already at that version, just say so
     */
    if (strcmp(oldVersionName, versionName) == 0)
    {
        ereport(NOTICE,
                (errmsg("version \"%s\" of extension \"%s\" is already installed",
                        versionName, stmt->extname)));
        return InvalidObjectAddress;
    }
 
    /*
     * Identify the series of update script files we need to execute
     */
    updateVersions = identify_update_path(control,
                                          oldVersionName,
                                          versionName);
 
    /*
     * Update the pg_extension row and execute the update scripts, one at a
     * time
     */
    ApplyExtensionUpdates(extensionOid, control,
                          oldVersionName, updateVersions,
                          NULL, false, false);
 
    ObjectAddressSet(address, ExtensionRelationId, extensionOid);
 
    return address;
}

References AccessShareLock, aclcheck_error(), ACLCHECK_NOT_OWNER, ApplyExtensionUpdates(), DefElem::arg, BTEqualStrategyNumber, check_valid_version_name(), creating_extension, CStringGetDatum(), DatumGetTextPP, ExtensionControlFile::default_version, DefElem::defname, elog(), ereport, errcode(), errmsg(), ERROR, errorConflictingDefElem(), GETSTRUCT, GetUserId(), heap_getattr(), HeapTupleIsValid, identify_update_path(), InvalidObjectAddress, sort-test::key, lfirst, NOTICE, OBJECT_EXTENSION, object_ownercheck(), ObjectAddressSet, read_extension_control_file(), RelationGetDescr, ScanKeyInit(), stmt, strVal, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and text_to_cstring().

Referenced by ProcessUtilitySlow().

execute_extension_script()

static void execute_extension_script ( Oid  extensionOid, ExtensionControlFile *  control, const char *  from_version, const char *  version, List *  requiredSchemas, const char *  schemaName, Oid  schemaOid  )

static

Definition at line 869 of file extension.c.

{
    bool        switch_to_superuser = false;
    char       *filename;
    Oid         save_userid = 0;
    int         save_sec_context = 0;
    int         save_nestlevel;
    StringInfoData pathbuf;
    ListCell   *lc;
    ListCell   *lc2;
 
    /*
     * Enforce superuser-ness if appropriate.  We postpone these checks until
     * here so that the control flags are correctly associated with the right
     * script(s) if they happen to be set in secondary control files.
     */
    if (control->superuser && !superuser())
    {
        if (extension_is_trusted(control))
            switch_to_superuser = true;
        else if (from_version == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("permission denied to create extension \"%s\"",
                            control->name),
                     control->trusted
                     ? errhint("Must have CREATE privilege on current database to create this extension.")
                     : errhint("Must be superuser to create this extension.")));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("permission denied to update extension \"%s\"",
                            control->name),
                     control->trusted
                     ? errhint("Must have CREATE privilege on current database to update this extension.")
                     : errhint("Must be superuser to update this extension.")));
    }
 
    filename = get_extension_script_filename(control, from_version, version);
 
    if (from_version == NULL)
        elog(DEBUG1, "executing extension script for \"%s\" version '%s'", control->name, version);
    else
        elog(DEBUG1, "executing extension script for \"%s\" update from version '%s' to '%s'", control->name, from_version, version);
 
    /*
     * If installing a trusted extension on behalf of a non-superuser, become
     * the bootstrap superuser.  (This switch will be cleaned up automatically
     * if the transaction aborts, as will the GUC changes below.)
     */
    if (switch_to_superuser)
    {
        GetUserIdAndSecContext(&save_userid, &save_sec_context);
        SetUserIdAndSecContext(BOOTSTRAP_SUPERUSERID,
                               save_sec_context | SECURITY_LOCAL_USERID_CHANGE);
    }
 
    /*
     * Force client_min_messages and log_min_messages to be at least WARNING,
     * so that we won't spam the user with useless NOTICE messages from common
     * script actions like creating shell types.
     *
     * We use the equivalent of a function SET option to allow the setting to
     * persist for exactly the duration of the script execution.  guc.c also
     * takes care of undoing the setting on error.
     *
     * log_min_messages can't be set by ordinary users, so for that one we
     * pretend to be superuser.
     */
    save_nestlevel = NewGUCNestLevel();
 
    if (client_min_messages < WARNING)
        (void) set_config_option("client_min_messages", "warning",
                                 PGC_USERSET, PGC_S_SESSION,
                                 GUC_ACTION_SAVE, true, 0, false);
    if (log_min_messages < WARNING)
        (void) set_config_option_ext("log_min_messages", "warning",
                                     PGC_SUSET, PGC_S_SESSION,
                                     BOOTSTRAP_SUPERUSERID,
                                     GUC_ACTION_SAVE, true, 0, false);
 
    /*
     * Similarly disable check_function_bodies, to ensure that SQL functions
     * won't be parsed during creation.
     */
    if (check_function_bodies)
        (void) set_config_option("check_function_bodies", "off",
                                 PGC_USERSET, PGC_S_SESSION,
                                 GUC_ACTION_SAVE, true, 0, false);
 
    /*
     * Set up the search path to have the target schema first, making it be
     * the default creation target namespace.  Then add the schemas of any
     * prerequisite extensions, unless they are in pg_catalog which would be
     * searched anyway.  (Listing pg_catalog explicitly in a non-first
     * position would be bad for security.)  Finally add pg_temp to ensure
     * that temp objects can't take precedence over others.
     *
     * Note: it might look tempting to use PushOverrideSearchPath for this,
     * but we cannot do that.  We have to actually set the search_path GUC in
     * case the extension script examines or changes it.  In any case, the
     * GUC_ACTION_SAVE method is just as convenient.
     */
    initStringInfo(&pathbuf);
    appendStringInfoString(&pathbuf, quote_identifier(schemaName));
    foreach(lc, requiredSchemas)
    {
        Oid         reqschema = lfirst_oid(lc);
        char       *reqname = get_namespace_name(reqschema);
 
        if (reqname && strcmp(reqname, "pg_catalog") != 0)
            appendStringInfo(&pathbuf, ", %s", quote_identifier(reqname));
    }
    appendStringInfoString(&pathbuf, ", pg_temp");
 
    (void) set_config_option("search_path", pathbuf.data,
                             PGC_USERSET, PGC_S_SESSION,
                             GUC_ACTION_SAVE, true, 0, false);
 
    /*
     * Set creating_extension and related variables so that
     * recordDependencyOnCurrentExtension and other functions do the right
     * things.  On failure, ensure we reset these variables.
     */
    creating_extension = true;
    CurrentExtensionObject = extensionOid;
    PG_TRY();
    {
        char       *c_sql = read_extension_script_file(control, filename);
        Datum       t_sql;
 
        /* We use various functions that want to operate on text datums */
        t_sql = CStringGetTextDatum(c_sql);
 
        /*
         * Reduce any lines beginning with "\echo" to empty.  This allows
         * scripts to contain messages telling people not to run them via
         * psql, which has been found to be necessary due to old habits.
         */
        t_sql = DirectFunctionCall4Coll(textregexreplace,
                                        C_COLLATION_OID,
                                        t_sql,
                                        CStringGetTextDatum("^\\\\echo.*$"),
                                        CStringGetTextDatum(""),
                                        CStringGetTextDatum("ng"));
 
        /*
         * If the script uses @extowner@, substitute the calling username.
         */
        if (strstr(c_sql, "@extowner@"))
        {
            Oid         uid = switch_to_superuser ? save_userid : GetUserId();
            const char *userName = GetUserNameFromId(uid, false);
            const char *qUserName = quote_identifier(userName);
 
            t_sql = DirectFunctionCall3Coll(replace_text,
                                            C_COLLATION_OID,
                                            t_sql,
                                            CStringGetTextDatum("@extowner@"),
                                            CStringGetTextDatum(qUserName));
        }
 
        /*
         * If it's not relocatable, substitute the target schema name for
         * occurrences of @extschema@.
         *
         * For a relocatable extension, we needn't do this.  There cannot be
         * any need for @extschema@, else it wouldn't be relocatable.
         */
        if (!control->relocatable)
        {
            const char *qSchemaName = quote_identifier(schemaName);
 
            t_sql = DirectFunctionCall3Coll(replace_text,
                                            C_COLLATION_OID,
                                            t_sql,
                                            CStringGetTextDatum("@extschema@"),
                                            CStringGetTextDatum(qSchemaName));
        }
 
        /*
         * Likewise, substitute required extensions' schema names for
         * occurrences of @extschema:extension_name@.
         */
        Assert(list_length(control->requires) == list_length(requiredSchemas));
        forboth(lc, control->requires, lc2, requiredSchemas)
        {
            char       *reqextname = (char *) lfirst(lc);
            Oid         reqschema = lfirst_oid(lc2);
            char       *schemaName = get_namespace_name(reqschema);
            const char *qSchemaName = quote_identifier(schemaName);
            char       *repltoken;
 
            repltoken = psprintf("@extschema:%s@", reqextname);
            t_sql = DirectFunctionCall3Coll(replace_text,
                                            C_COLLATION_OID,
                                            t_sql,
                                            CStringGetTextDatum(repltoken),
                                            CStringGetTextDatum(qSchemaName));
        }
 
        /*
         * If module_pathname was set in the control file, substitute its
         * value for occurrences of MODULE_PATHNAME.
         */
        if (control->module_pathname)
        {
            t_sql = DirectFunctionCall3Coll(replace_text,
                                            C_COLLATION_OID,
                                            t_sql,
                                            CStringGetTextDatum("MODULE_PATHNAME"),
                                            CStringGetTextDatum(control->module_pathname));
        }
 
        /* And now back to C string */
        c_sql = text_to_cstring(DatumGetTextPP(t_sql));
 
        execute_sql_string(c_sql);
    }
    PG_FINALLY();
    {
        creating_extension = false;
        CurrentExtensionObject = InvalidOid;
    }
    PG_END_TRY();
 
    /*
     * Restore the GUC variables we set above.
     */
    AtEOXact_GUC(true, save_nestlevel);
 
    /*
     * Restore authentication state if needed.
     */
    if (switch_to_superuser)
        SetUserIdAndSecContext(save_userid, save_sec_context);
}

References appendStringInfo(), appendStringInfoString(), Assert(), AtEOXact_GUC(), check_function_bodies, client_min_messages, creating_extension, CStringGetTextDatum, CurrentExtensionObject, StringInfoData::data, DatumGetTextPP, DEBUG1, DirectFunctionCall3Coll(), DirectFunctionCall4Coll(), elog(), ereport, errcode(), errhint(), errmsg(), ERROR, execute_sql_string(), extension_is_trusted(), filename, forboth, get_extension_script_filename(), get_namespace_name(), GetUserId(), GetUserIdAndSecContext(), GetUserNameFromId(), GUC_ACTION_SAVE, initStringInfo(), InvalidOid, lfirst, lfirst_oid, list_length(), log_min_messages, ExtensionControlFile::module_pathname, ExtensionControlFile::name, NewGUCNestLevel(), PG_END_TRY, PG_FINALLY, PG_TRY, PGC_S_SESSION, PGC_SUSET, PGC_USERSET, psprintf(), quote_identifier(), read_extension_script_file(), ExtensionControlFile::relocatable, replace_text(), ExtensionControlFile::requires, SECURITY_LOCAL_USERID_CHANGE, set_config_option(), set_config_option_ext(), SetUserIdAndSecContext(), ExtensionControlFile::superuser, superuser(), text_to_cstring(), textregexreplace(), ExtensionControlFile::trusted, and WARNING.

Referenced by ApplyExtensionUpdates(), and CreateExtensionInternal().

execute_sql_string()

static void execute_sql_string ( const char *  sql )

static

Definition at line 740 of file extension.c.

{
    List       *raw_parsetree_list;
    DestReceiver *dest;
    ListCell   *lc1;
 
    /*
     * Parse the SQL string into a list of raw parse trees.
     */
    raw_parsetree_list = pg_parse_query(sql);
 
    /* All output from SELECTs goes to the bit bucket */
    dest = CreateDestReceiver(DestNone);
 
    /*
     * Do parse analysis, rule rewrite, planning, and execution for each raw
     * parsetree.  We must fully execute each query before beginning parse
     * analysis on the next one, since there may be interdependencies.
     */
    foreach(lc1, raw_parsetree_list)
    {
        RawStmt    *parsetree = lfirst_node(RawStmt, lc1);
        MemoryContext per_parsetree_context,
                    oldcontext;
        List       *stmt_list;
        ListCell   *lc2;
 
        /*
         * We do the work for each parsetree in a short-lived context, to
         * limit the memory used when there are many commands in the string.
         */
        per_parsetree_context =
            AllocSetContextCreate(CurrentMemoryContext,
                                  "execute_sql_string per-statement context",
                                  ALLOCSET_DEFAULT_SIZES);
        oldcontext = MemoryContextSwitchTo(per_parsetree_context);
 
        /* Be sure parser can see any DDL done so far */
        CommandCounterIncrement();
 
        stmt_list = pg_analyze_and_rewrite_fixedparams(parsetree,
                                                       sql,
                                                       NULL,
                                                       0,
                                                       NULL);
        stmt_list = pg_plan_queries(stmt_list, sql, CURSOR_OPT_PARALLEL_OK, NULL);
 
        foreach(lc2, stmt_list)
        {
            PlannedStmt *stmt = lfirst_node(PlannedStmt, lc2);
 
            CommandCounterIncrement();
 
            PushActiveSnapshot(GetTransactionSnapshot());
 
            if (stmt->utilityStmt == NULL)
            {
                QueryDesc  *qdesc;
 
                qdesc = CreateQueryDesc(stmt,
                                        sql,
                                        GetActiveSnapshot(), NULL,
                                        dest, NULL, NULL, 0);
 
                ExecutorStart(qdesc, 0);
                ExecutorRun(qdesc, ForwardScanDirection, 0, true);
                ExecutorFinish(qdesc);
                ExecutorEnd(qdesc);
 
                FreeQueryDesc(qdesc);
            }
            else
            {
                if (IsA(stmt->utilityStmt, TransactionStmt))
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("transaction control statements are not allowed within an extension script")));
 
                ProcessUtility(stmt,
                               sql,
                               false,
                               PROCESS_UTILITY_QUERY,
                               NULL,
                               NULL,
                               dest,
                               NULL);
            }
 
            PopActiveSnapshot();
        }
 
        /* Clean up per-parsetree context. */
        MemoryContextSwitchTo(oldcontext);
        MemoryContextDelete(per_parsetree_context);
    }
 
    /* Be sure to advance the command counter after the last script command */
    CommandCounterIncrement();
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CommandCounterIncrement(), CreateDestReceiver(), CreateQueryDesc(), CurrentMemoryContext, CURSOR_OPT_PARALLEL_OK, generate_unaccent_rules::dest, DestNone, ereport, errcode(), errmsg(), ERROR, ExecutorEnd(), ExecutorFinish(), ExecutorRun(), ExecutorStart(), ForwardScanDirection, FreeQueryDesc(), GetActiveSnapshot(), GetTransactionSnapshot(), IsA, lfirst_node, MemoryContextDelete(), MemoryContextSwitchTo(), pg_analyze_and_rewrite_fixedparams(), pg_parse_query(), pg_plan_queries(), PopActiveSnapshot(), PROCESS_UTILITY_QUERY, ProcessUtility(), PushActiveSnapshot(), and stmt.

Referenced by execute_extension_script().

extension_config_remove()

static void extension_config_remove ( Oid  extensionoid, Oid  tableoid  )

static

Definition at line 2584 of file extension.c.

{
    Relation    extRel;
    ScanKeyData key[1];
    SysScanDesc extScan;
    HeapTuple   extTup;
    Datum       arrayDatum;
    int         arrayLength;
    int         arrayIndex;
    bool        isnull;
    Datum       repl_val[Natts_pg_extension];
    bool        repl_null[Natts_pg_extension];
    bool        repl_repl[Natts_pg_extension];
    ArrayType  *a;
 
    /* Find the pg_extension tuple */
    extRel = table_open(ExtensionRelationId, RowExclusiveLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_extension_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(extensionoid));
 
    extScan = systable_beginscan(extRel, ExtensionOidIndexId, true,
                                 NULL, 1, key);
 
    extTup = systable_getnext(extScan);
 
    if (!HeapTupleIsValid(extTup))  /* should not happen */
        elog(ERROR, "could not find tuple for extension %u",
             extensionoid);
 
    /* Search extconfig for the tableoid */
    arrayDatum = heap_getattr(extTup, Anum_pg_extension_extconfig,
                              RelationGetDescr(extRel), &isnull);
    if (isnull)
    {
        /* nothing to do */
        a = NULL;
        arrayLength = 0;
        arrayIndex = -1;
    }
    else
    {
        Oid        *arrayData;
        int         i;
 
        a = DatumGetArrayTypeP(arrayDatum);
 
        arrayLength = ARR_DIMS(a)[0];
        if (ARR_NDIM(a) != 1 ||
            ARR_LBOUND(a)[0] != 1 ||
            arrayLength < 0 ||
            ARR_HASNULL(a) ||
            ARR_ELEMTYPE(a) != OIDOID)
            elog(ERROR, "extconfig is not a 1-D Oid array");
        arrayData = (Oid *) ARR_DATA_PTR(a);
 
        arrayIndex = -1;        /* flag for no deletion needed */
 
        for (i = 0; i < arrayLength; i++)
        {
            if (arrayData[i] == tableoid)
            {
                arrayIndex = i; /* index to remove */
                break;
            }
        }
    }
 
    /* If tableoid is not in extconfig, nothing to do */
    if (arrayIndex < 0)
    {
        systable_endscan(extScan);
        table_close(extRel, RowExclusiveLock);
        return;
    }
 
    /* Modify or delete the extconfig value */
    memset(repl_val, 0, sizeof(repl_val));
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));
 
    if (arrayLength <= 1)
    {
        /* removing only element, just set array to null */
        repl_null[Anum_pg_extension_extconfig - 1] = true;
    }
    else
    {
        /* squeeze out the target element */
        Datum      *dvalues;
        int         nelems;
        int         i;
 
        /* We already checked there are no nulls */
        deconstruct_array_builtin(a, OIDOID, &dvalues, NULL, &nelems);
 
        for (i = arrayIndex; i < arrayLength - 1; i++)
            dvalues[i] = dvalues[i + 1];
 
        a = construct_array_builtin(dvalues, arrayLength - 1, OIDOID);
 
        repl_val[Anum_pg_extension_extconfig - 1] = PointerGetDatum(a);
    }
    repl_repl[Anum_pg_extension_extconfig - 1] = true;
 
    /* Modify or delete the extcondition value */
    arrayDatum = heap_getattr(extTup, Anum_pg_extension_extcondition,
                              RelationGetDescr(extRel), &isnull);
    if (isnull)
    {
        elog(ERROR, "extconfig and extcondition arrays do not match");
    }
    else
    {
        a = DatumGetArrayTypeP(arrayDatum);
 
        if (ARR_NDIM(a) != 1 ||
            ARR_LBOUND(a)[0] != 1 ||
            ARR_HASNULL(a) ||
            ARR_ELEMTYPE(a) != TEXTOID)
            elog(ERROR, "extcondition is not a 1-D text array");
        if (ARR_DIMS(a)[0] != arrayLength)
            elog(ERROR, "extconfig and extcondition arrays do not match");
    }
 
    if (arrayLength <= 1)
    {
        /* removing only element, just set array to null */
        repl_null[Anum_pg_extension_extcondition - 1] = true;
    }
    else
    {
        /* squeeze out the target element */
        Datum      *dvalues;
        int         nelems;
        int         i;
 
        /* We already checked there are no nulls */
        deconstruct_array_builtin(a, TEXTOID, &dvalues, NULL, &nelems);
 
        for (i = arrayIndex; i < arrayLength - 1; i++)
            dvalues[i] = dvalues[i + 1];
 
        a = construct_array_builtin(dvalues, arrayLength - 1, TEXTOID);
 
        repl_val[Anum_pg_extension_extcondition - 1] = PointerGetDatum(a);
    }
    repl_repl[Anum_pg_extension_extcondition - 1] = true;
 
    extTup = heap_modify_tuple(extTup, RelationGetDescr(extRel),
                               repl_val, repl_null, repl_repl);
 
    CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
 
    systable_endscan(extScan);
 
    table_close(extRel, RowExclusiveLock);
}

References a, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_LBOUND, ARR_NDIM, BTEqualStrategyNumber, CatalogTupleUpdate(), construct_array_builtin(), DatumGetArrayTypeP, deconstruct_array_builtin(), elog(), ERROR, heap_getattr(), heap_modify_tuple(), HeapTupleIsValid, i, sort-test::key, ObjectIdGetDatum(), PointerGetDatum(), RelationGetDescr, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ExecAlterExtensionContentsStmt().

extension_file_exists()

bool extension_file_exists

(

const char *

extensionName

)

Definition at line 2237 of file extension.c.

{
    bool        result = false;
    char       *location;
    DIR        *dir;
    struct dirent *de;
 
    location = get_extension_control_directory();
    dir = AllocateDir(location);
 
    /*
     * If the control directory doesn't exist, we want to silently return
     * false.  Any other error will be reported by ReadDir.
     */
    if (dir == NULL && errno == ENOENT)
    {
        /* do nothing */
    }
    else
    {
        while ((de = ReadDir(dir, location)) != NULL)
        {
            char       *extname;
 
            if (!is_extension_control_filename(de->d_name))
                continue;
 
            /* extract extension name from 'name.control' filename */
            extname = pstrdup(de->d_name);
            *strrchr(extname, '.') = '\0';
 
            /* ignore it if it's an auxiliary control file */
            if (strstr(extname, "--"))
                continue;
 
            /* done if it matches request */
            if (strcmp(extname, extensionName) == 0)
            {
                result = true;
                break;
            }
        }
 
        FreeDir(dir);
    }
 
    return result;
}

References AllocateDir(), dirent::d_name, FreeDir(), get_extension_control_directory(), is_extension_control_filename(), pstrdup(), and ReadDir().

Referenced by CreateFunction(), and ExecuteDoStmt().

extension_is_trusted()

static bool extension_is_trusted ( ExtensionControlFile *  control )

static

Definition at line 847 of file extension.c.

{
    AclResult   aclresult;
 
    /* Never trust unless extension's control file says it's okay */
    if (!control->trusted)
        return false;
    /* Allow if user has CREATE privilege on current database */
    aclresult = object_aclcheck(DatabaseRelationId, MyDatabaseId, GetUserId(), ACL_CREATE);
    if (aclresult == ACLCHECK_OK)
        return true;
    return false;
}

References ACL_CREATE, ACLCHECK_OK, GetUserId(), MyDatabaseId, object_aclcheck(), and ExtensionControlFile::trusted.

Referenced by execute_extension_script().

find_install_path()

static ExtensionVersionInfo* find_install_path ( List *  evi_list, ExtensionVersionInfo *  evi_target, List **  best_path  )

static

Definition at line 1380 of file extension.c.

{
    ExtensionVersionInfo *evi_start = NULL;
    ListCell   *lc;
 
    *best_path = NIL;
 
    /*
     * We don't expect to be called for an installable target, but if we are,
     * the answer is easy: just start from there, with an empty update path.
     */
    if (evi_target->installable)
        return evi_target;
 
    /* Consider all installable versions as start points */
    foreach(lc, evi_list)
    {
        ExtensionVersionInfo *evi1 = (ExtensionVersionInfo *) lfirst(lc);
        List       *path;
 
        if (!evi1->installable)
            continue;
 
        /*
         * Find shortest path from evi1 to evi_target; but no need to consider
         * paths going through other installable versions.
         */
        path = find_update_path(evi_list, evi1, evi_target, true, true);
        if (path == NIL)
            continue;
 
        /* Remember best path */
        if (evi_start == NULL ||
            list_length(path) < list_length(*best_path) ||
            (list_length(path) == list_length(*best_path) &&
             strcmp(evi_start->name, evi1->name) < 0))
        {
            evi_start = evi1;
            *best_path = path;
        }
    }
 
    return evi_start;
}

References find_update_path(), ExtensionVersionInfo::installable, lfirst, list_length(), ExtensionVersionInfo::name, and NIL.

Referenced by CreateExtensionInternal(), and get_available_versions_for_extension().

find_update_path()

static List * find_update_path ( List *  evi_list, ExtensionVersionInfo *  evi_start, ExtensionVersionInfo *  evi_target, bool  reject_indirect, bool  reinitialize  )

static

Definition at line 1287 of file extension.c.

{
    List       *result;
    ExtensionVersionInfo *evi;
    ListCell   *lc;
 
    /* Caller error if start == target */
    Assert(evi_start != evi_target);
    /* Caller error if reject_indirect and target is installable */
    Assert(!(reject_indirect && evi_target->installable));
 
    if (reinitialize)
    {
        foreach(lc, evi_list)
        {
            evi = (ExtensionVersionInfo *) lfirst(lc);
            evi->distance_known = false;
            evi->distance = INT_MAX;
            evi->previous = NULL;
        }
    }
 
    evi_start->distance = 0;
 
    while ((evi = get_nearest_unprocessed_vertex(evi_list)) != NULL)
    {
        if (evi->distance == INT_MAX)
            break;              /* all remaining vertices are unreachable */
        evi->distance_known = true;
        if (evi == evi_target)
            break;              /* found shortest path to target */
        foreach(lc, evi->reachable)
        {
            ExtensionVersionInfo *evi2 = (ExtensionVersionInfo *) lfirst(lc);
            int         newdist;
 
            /* if reject_indirect, treat installable versions as unreachable */
            if (reject_indirect && evi2->installable)
                continue;
            newdist = evi->distance + 1;
            if (newdist < evi2->distance)
            {
                evi2->distance = newdist;
                evi2->previous = evi;
            }
            else if (newdist == evi2->distance &&
                     evi2->previous != NULL &&
                     strcmp(evi->name, evi2->previous->name) < 0)
            {
                /*
                 * Break ties in favor of the version name that comes first
                 * according to strcmp().  This behavior is undocumented and
                 * users shouldn't rely on it.  We do it just to ensure that
                 * if there is a tie, the update path that is chosen does not
                 * depend on random factors like the order in which directory
                 * entries get visited.
                 */
                evi2->previous = evi;
            }
        }
    }
 
    /* Return NIL if target is not reachable from start */
    if (!evi_target->distance_known)
        return NIL;
 
    /* Build and return list of version names representing the update path */
    result = NIL;
    for (evi = evi_target; evi != evi_start; evi = evi->previous)
        result = lcons(evi->name, result);
 
    return result;
}

References Assert(), ExtensionVersionInfo::distance, ExtensionVersionInfo::distance_known, get_nearest_unprocessed_vertex(), ExtensionVersionInfo::installable, lcons(), lfirst, ExtensionVersionInfo::name, NIL, ExtensionVersionInfo::previous, and ExtensionVersionInfo::reachable.

Referenced by find_install_path(), identify_update_path(), and pg_extension_update_paths().

get_available_versions_for_extension()

static void get_available_versions_for_extension ( ExtensionControlFile *  pcontrol, Tuplestorestate *  tupstore, TupleDesc  tupdesc  )

static

Definition at line 2123 of file extension.c.

{
    List       *evi_list;
    ListCell   *lc;
 
    /* Extract the version update graph from the script directory */
    evi_list = get_ext_ver_list(pcontrol);
 
    /* For each installable version ... */
    foreach(lc, evi_list)
    {
        ExtensionVersionInfo *evi = (ExtensionVersionInfo *) lfirst(lc);
        ExtensionControlFile *control;
        Datum       values[8];
        bool        nulls[8];
        ListCell   *lc2;
 
        if (!evi->installable)
            continue;
 
        /*
         * Fetch parameters for specific version (pcontrol is not changed)
         */
        control = read_extension_aux_control_file(pcontrol, evi->name);
 
        memset(values, 0, sizeof(values));
        memset(nulls, 0, sizeof(nulls));
 
        /* name */
        values[0] = DirectFunctionCall1(namein,
                                        CStringGetDatum(control->name));
        /* version */
        values[1] = CStringGetTextDatum(evi->name);
        /* superuser */
        values[2] = BoolGetDatum(control->superuser);
        /* trusted */
        values[3] = BoolGetDatum(control->trusted);
        /* relocatable */
        values[4] = BoolGetDatum(control->relocatable);
        /* schema */
        if (control->schema == NULL)
            nulls[5] = true;
        else
            values[5] = DirectFunctionCall1(namein,
                                            CStringGetDatum(control->schema));
        /* requires */
        if (control->requires == NIL)
            nulls[6] = true;
        else
            values[6] = convert_requires_to_datum(control->requires);
        /* comment */
        if (control->comment == NULL)
            nulls[7] = true;
        else
            values[7] = CStringGetTextDatum(control->comment);
 
        tuplestore_putvalues(tupstore, tupdesc, values, nulls);
 
        /*
         * Find all non-directly-installable versions that would be installed
         * starting from this version, and report them, inheriting the
         * parameters that aren't changed in updates from this version.
         */
        foreach(lc2, evi_list)
        {
            ExtensionVersionInfo *evi2 = (ExtensionVersionInfo *) lfirst(lc2);
            List       *best_path;
 
            if (evi2->installable)
                continue;
            if (find_install_path(evi_list, evi2, &best_path) == evi)
            {
                /*
                 * Fetch parameters for this version (pcontrol is not changed)
                 */
                control = read_extension_aux_control_file(pcontrol, evi2->name);
 
                /* name stays the same */
                /* version */
                values[1] = CStringGetTextDatum(evi2->name);
                /* superuser */
                values[2] = BoolGetDatum(control->superuser);
                /* trusted */
                values[3] = BoolGetDatum(control->trusted);
                /* relocatable */
                values[4] = BoolGetDatum(control->relocatable);
                /* schema stays the same */
                /* requires */
                if (control->requires == NIL)
                    nulls[6] = true;
                else
                {
                    values[6] = convert_requires_to_datum(control->requires);
                    nulls[6] = false;
                }
                /* comment stays the same */
 
                tuplestore_putvalues(tupstore, tupdesc, values, nulls);
            }
        }
    }
}

References BoolGetDatum(), ExtensionControlFile::comment, convert_requires_to_datum(), CStringGetDatum(), CStringGetTextDatum, DirectFunctionCall1, find_install_path(), get_ext_ver_list(), ExtensionVersionInfo::installable, lfirst, ExtensionControlFile::name, ExtensionVersionInfo::name, namein(), NIL, read_extension_aux_control_file(), ExtensionControlFile::relocatable, ExtensionControlFile::requires, ExtensionControlFile::schema, ExtensionControlFile::superuser, ExtensionControlFile::trusted, tuplestore_putvalues(), and values.

Referenced by pg_available_extension_versions().

get_ext_ver_info()

static ExtensionVersionInfo* get_ext_ver_info ( const char *  versionname, List **  evi_list  )

static

Definition at line 1120 of file extension.c.

{
    ExtensionVersionInfo *evi;
    ListCell   *lc;
 
    foreach(lc, *evi_list)
    {
        evi = (ExtensionVersionInfo *) lfirst(lc);
        if (strcmp(evi->name, versionname) == 0)
            return evi;
    }
 
    evi = (ExtensionVersionInfo *) palloc(sizeof(ExtensionVersionInfo));
    evi->name = pstrdup(versionname);
    evi->reachable = NIL;
    evi->installable = false;
    /* initialize for later application of Dijkstra's algorithm */
    evi->distance_known = false;
    evi->distance = INT_MAX;
    evi->previous = NULL;
 
    *evi_list = lappend(*evi_list, evi);
 
    return evi;
}

References ExtensionVersionInfo::distance, ExtensionVersionInfo::distance_known, ExtensionVersionInfo::installable, lappend(), lfirst, ExtensionVersionInfo::name, NIL, palloc(), ExtensionVersionInfo::previous, pstrdup(), and ExtensionVersionInfo::reachable.

Referenced by CreateExtensionInternal(), get_ext_ver_list(), and identify_update_path().

get_ext_ver_list()

static List* get_ext_ver_list ( ExtensionControlFile *  control )

static

Definition at line 1181 of file extension.c.

{
    List       *evi_list = NIL;
    int         extnamelen = strlen(control->name);
    char       *location;
    DIR        *dir;
    struct dirent *de;
 
    location = get_extension_script_directory(control);
    dir = AllocateDir(location);
    while ((de = ReadDir(dir, location)) != NULL)
    {
        char       *vername;
        char       *vername2;
        ExtensionVersionInfo *evi;
        ExtensionVersionInfo *evi2;
 
        /* must be a .sql file ... */
        if (!is_extension_script_filename(de->d_name))
            continue;
 
        /* ... matching extension name followed by separator */
        if (strncmp(de->d_name, control->name, extnamelen) != 0 ||
            de->d_name[extnamelen] != '-' ||
            de->d_name[extnamelen + 1] != '-')
            continue;
 
        /* extract version name(s) from 'extname--something.sql' filename */
        vername = pstrdup(de->d_name + extnamelen + 2);
        *strrchr(vername, '.') = '\0';
        vername2 = strstr(vername, "--");
        if (!vername2)
        {
            /* It's an install, not update, script; record its version name */
            evi = get_ext_ver_info(vername, &evi_list);
            evi->installable = true;
            continue;
        }
        *vername2 = '\0';       /* terminate first version */
        vername2 += 2;          /* and point to second */
 
        /* if there's a third --, it's bogus, ignore it */
        if (strstr(vername2, "--"))
            continue;
 
        /* Create ExtensionVersionInfos and link them together */
        evi = get_ext_ver_info(vername, &evi_list);
        evi2 = get_ext_ver_info(vername2, &evi_list);
        evi->reachable = lappend(evi->reachable, evi2);
    }
    FreeDir(dir);
 
    return evi_list;
}

References AllocateDir(), dirent::d_name, FreeDir(), get_ext_ver_info(), get_extension_script_directory(), ExtensionVersionInfo::installable, is_extension_script_filename(), lappend(), ExtensionControlFile::name, NIL, pstrdup(), ExtensionVersionInfo::reachable, and ReadDir().

Referenced by CreateExtensionInternal(), get_available_versions_for_extension(), identify_update_path(), and pg_extension_update_paths().

get_extension_aux_control_filename()

static char* get_extension_aux_control_filename ( ExtensionControlFile *  control, const char *  version  )

static

Definition at line 425 of file extension.c.

{
    char       *result;
    char       *scriptdir;
 
    scriptdir = get_extension_script_directory(control);
 
    result = (char *) palloc(MAXPGPATH);
    snprintf(result, MAXPGPATH, "%s/%s--%s.control",
             scriptdir, control->name, version);
 
    pfree(scriptdir);
 
    return result;
}

References get_extension_script_directory(), MAXPGPATH, ExtensionControlFile::name, palloc(), pfree(), and snprintf.

Referenced by parse_extension_control_file().

get_extension_control_directory()

static char* get_extension_control_directory ( void  )

static

Definition at line 375 of file extension.c.

{
    char        sharepath[MAXPGPATH];
    char       *result;
 
    get_share_path(my_exec_path, sharepath);
    result = (char *) palloc(MAXPGPATH);
    snprintf(result, MAXPGPATH, "%s/extension", sharepath);
 
    return result;
}

References get_share_path(), MAXPGPATH, my_exec_path, palloc(), and snprintf.

Referenced by extension_file_exists(), get_extension_script_directory(), pg_available_extension_versions(), and pg_available_extensions().

get_extension_control_filename()

static char* get_extension_control_filename ( const char *  extname )

static

Definition at line 388 of file extension.c.

{
    char        sharepath[MAXPGPATH];
    char       *result;
 
    get_share_path(my_exec_path, sharepath);
    result = (char *) palloc(MAXPGPATH);
    snprintf(result, MAXPGPATH, "%s/extension/%s.control",
             sharepath, extname);
 
    return result;
}

References get_share_path(), MAXPGPATH, my_exec_path, palloc(), and snprintf.

Referenced by parse_extension_control_file().

get_extension_name()

char* get_extension_name

(

Oid

ext_oid

)

Definition at line 189 of file extension.c.

{
    char       *result;
    Relation    rel;
    SysScanDesc scandesc;
    HeapTuple   tuple;
    ScanKeyData entry[1];
 
    rel = table_open(ExtensionRelationId, AccessShareLock);
 
    ScanKeyInit(&entry[0],
                Anum_pg_extension_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(ext_oid));
 
    scandesc = systable_beginscan(rel, ExtensionOidIndexId, true,
                                  NULL, 1, entry);
 
    tuple = systable_getnext(scandesc);
 
    /* We assume that there can be at most one matching tuple */
    if (HeapTupleIsValid(tuple))
        result = pstrdup(NameStr(((Form_pg_extension) GETSTRUCT(tuple))->extname));
    else
        result = NULL;
 
    systable_endscan(scandesc);
 
    table_close(rel, AccessShareLock);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), pstrdup(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterExtensionNamespace(), checkMembershipInCurrentExtension(), ExecAlterExtensionContentsStmt(), getObjectDescription(), getObjectIdentityParts(), recordDependencyOnCurrentExtension(), and RemoveExtensionById().

get_extension_oid()

Oid get_extension_oid	(	const char *	extname,
		bool	missing_ok
	)

Definition at line 144 of file extension.c.

{
    Oid         result;
    Relation    rel;
    SysScanDesc scandesc;
    HeapTuple   tuple;
    ScanKeyData entry[1];
 
    rel = table_open(ExtensionRelationId, AccessShareLock);
 
    ScanKeyInit(&entry[0],
                Anum_pg_extension_extname,
                BTEqualStrategyNumber, F_NAMEEQ,
                CStringGetDatum(extname));
 
    scandesc = systable_beginscan(rel, ExtensionNameIndexId, true,
                                  NULL, 1, entry);
 
    tuple = systable_getnext(scandesc);
 
    /* We assume that there can be at most one matching tuple */
    if (HeapTupleIsValid(tuple))
        result = ((Form_pg_extension) GETSTRUCT(tuple))->oid;
    else
        result = InvalidOid;
 
    systable_endscan(scandesc);
 
    table_close(rel, AccessShareLock);
 
    if (!OidIsValid(result) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("extension \"%s\" does not exist",
                        extname)));
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, HeapTupleIsValid, InvalidOid, OidIsValid, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by AlterExtensionNamespace(), binary_upgrade_create_empty_extension(), CreateExtension(), ExtractExtensionList(), get_object_address_unqualified(), and get_required_extension().

get_extension_schema()

Oid get_extension_schema

(

Oid

ext_oid

)

Definition at line 228 of file extension.c.

{
    Oid         result;
    Relation    rel;
    SysScanDesc scandesc;
    HeapTuple   tuple;
    ScanKeyData entry[1];
 
    rel = table_open(ExtensionRelationId, AccessShareLock);
 
    ScanKeyInit(&entry[0],
                Anum_pg_extension_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(ext_oid));
 
    scandesc = systable_beginscan(rel, ExtensionOidIndexId, true,
                                  NULL, 1, entry);
 
    tuple = systable_getnext(scandesc);
 
    /* We assume that there can be at most one matching tuple */
    if (HeapTupleIsValid(tuple))
        result = ((Form_pg_extension) GETSTRUCT(tuple))->extnamespace;
    else
        result = InvalidOid;
 
    systable_endscan(scandesc);
 
    table_close(rel, AccessShareLock);
 
    return result;
}

References AccessShareLock, BTEqualStrategyNumber, GETSTRUCT, HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ApplyExtensionUpdates(), CreateExtensionInternal(), and ExecAlterExtensionContentsStmt().

get_extension_script_directory()

static char* get_extension_script_directory ( ExtensionControlFile *  control )

static

Definition at line 402 of file extension.c.

{
    char        sharepath[MAXPGPATH];
    char       *result;
 
    /*
     * The directory parameter can be omitted, absolute, or relative to the
     * installation's share directory.
     */
    if (!control->directory)
        return get_extension_control_directory();
 
    if (is_absolute_path(control->directory))
        return pstrdup(control->directory);
 
    get_share_path(my_exec_path, sharepath);
    result = (char *) palloc(MAXPGPATH);
    snprintf(result, MAXPGPATH, "%s/%s", sharepath, control->directory);
 
    return result;
}

References ExtensionControlFile::directory, get_extension_control_directory(), get_share_path(), is_absolute_path, MAXPGPATH, my_exec_path, palloc(), pstrdup(), and snprintf.

Referenced by get_ext_ver_list(), get_extension_aux_control_filename(), and get_extension_script_filename().

get_extension_script_filename()

static char* get_extension_script_filename ( ExtensionControlFile *  control, const char *  from_version, const char *  version  )

static

Definition at line 443 of file extension.c.

{
    char       *result;
    char       *scriptdir;
 
    scriptdir = get_extension_script_directory(control);
 
    result = (char *) palloc(MAXPGPATH);
    if (from_version)
        snprintf(result, MAXPGPATH, "%s/%s--%s--%s.sql",
                 scriptdir, control->name, from_version, version);
    else
        snprintf(result, MAXPGPATH, "%s/%s--%s.sql",
                 scriptdir, control->name, version);
 
    pfree(scriptdir);
 
    return result;
}

References get_extension_script_directory(), MAXPGPATH, ExtensionControlFile::name, palloc(), pfree(), and snprintf.

Referenced by CreateExtensionInternal(), and execute_extension_script().

get_nearest_unprocessed_vertex()

static ExtensionVersionInfo* get_nearest_unprocessed_vertex ( List *  evi_list )

static

Definition at line 1153 of file extension.c.

{
    ExtensionVersionInfo *evi = NULL;
    ListCell   *lc;
 
    foreach(lc, evi_list)
    {
        ExtensionVersionInfo *evi2 = (ExtensionVersionInfo *) lfirst(lc);
 
        /* only vertices whose distance is still uncertain are candidates */
        if (evi2->distance_known)
            continue;
        /* remember the closest such vertex */
        if (evi == NULL ||
            evi->distance > evi2->distance)
            evi = evi2;
    }
 
    return evi;
}

References ExtensionVersionInfo::distance, ExtensionVersionInfo::distance_known, and lfirst.

Referenced by find_update_path().

get_required_extension()

static Oid get_required_extension ( char *  reqExtensionName, char *  extensionName, char *  origSchemaName, bool  cascade, List *  parents, bool  is_create  )

static

Definition at line 1674 of file extension.c.

{
    Oid         reqExtensionOid;
 
    reqExtensionOid = get_extension_oid(reqExtensionName, true);
    if (!OidIsValid(reqExtensionOid))
    {
        if (cascade)
        {
            /* Must install it. */
            ObjectAddress addr;
            List       *cascade_parents;
            ListCell   *lc;
 
            /* Check extension name validity before trying to cascade. */
            check_valid_extension_name(reqExtensionName);
 
            /* Check for cyclic dependency between extensions. */
            foreach(lc, parents)
            {
                char       *pname = (char *) lfirst(lc);
 
                if (strcmp(pname, reqExtensionName) == 0)
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_RECURSION),
                             errmsg("cyclic dependency detected between extensions \"%s\" and \"%s\"",
                                    reqExtensionName, extensionName)));
            }
 
            ereport(NOTICE,
                    (errmsg("installing required extension \"%s\"",
                            reqExtensionName)));
 
            /* Add current extension to list of parents to pass down. */
            cascade_parents = lappend(list_copy(parents), extensionName);
 
            /*
             * Create the required extension.  We propagate the SCHEMA option
             * if any, and CASCADE, but no other options.
             */
            addr = CreateExtensionInternal(reqExtensionName,
                                           origSchemaName,
                                           NULL,
                                           cascade,
                                           cascade_parents,
                                           is_create);
 
            /* Get its newly-assigned OID. */
            reqExtensionOid = addr.objectId;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("required extension \"%s\" is not installed",
                            reqExtensionName),
                     is_create ?
                     errhint("Use CREATE EXTENSION ... CASCADE to install required extensions too.") : 0));
    }
 
    return reqExtensionOid;
}

References check_valid_extension_name(), CreateExtensionInternal(), ereport, errcode(), errhint(), errmsg(), ERROR, get_extension_oid(), lappend(), lfirst, list_copy(), NOTICE, ObjectAddress::objectId, and OidIsValid.

Referenced by ApplyExtensionUpdates(), and CreateExtensionInternal().

identify_update_path()

static List* identify_update_path ( ExtensionControlFile *  control, const char *  oldVersion, const char *  newVersion  )

static

Definition at line 1244 of file extension.c.

{
    List       *result;
    List       *evi_list;
    ExtensionVersionInfo *evi_start;
    ExtensionVersionInfo *evi_target;
 
    /* Extract the version update graph from the script directory */
    evi_list = get_ext_ver_list(control);
 
    /* Initialize start and end vertices */
    evi_start = get_ext_ver_info(oldVersion, &evi_list);
    evi_target = get_ext_ver_info(newVersion, &evi_list);
 
    /* Find shortest path */
    result = find_update_path(evi_list, evi_start, evi_target, false, false);
 
    if (result == NIL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("extension \"%s\" has no update path from version \"%s\" to version \"%s\"",
                        control->name, oldVersion, newVersion)));
 
    return result;
}

References ereport, errcode(), errmsg(), ERROR, find_update_path(), get_ext_ver_info(), get_ext_ver_list(), ExtensionControlFile::name, and NIL.

Referenced by ExecAlterExtensionStmt().

InsertExtensionTuple()

ObjectAddress InsertExtensionTuple	(	const char *	extName,
		Oid	extOwner,
		Oid	schemaOid,
		bool	relocatable,
		const char *	extVersion,
		Datum	extConfig,
		Datum	extCondition,
		List *	requiredExtensions
	)

Definition at line 1843 of file extension.c.

{
    Oid         extensionOid;
    Relation    rel;
    Datum       values[Natts_pg_extension];
    bool        nulls[Natts_pg_extension];
    HeapTuple   tuple;
    ObjectAddress myself;
    ObjectAddress nsp;
    ObjectAddresses *refobjs;
    ListCell   *lc;
 
    /*
     * Build and insert the pg_extension tuple
     */
    rel = table_open(ExtensionRelationId, RowExclusiveLock);
 
    memset(values, 0, sizeof(values));
    memset(nulls, 0, sizeof(nulls));
 
    extensionOid = GetNewOidWithIndex(rel, ExtensionOidIndexId,
                                      Anum_pg_extension_oid);
    values[Anum_pg_extension_oid - 1] = ObjectIdGetDatum(extensionOid);
    values[Anum_pg_extension_extname - 1] =
        DirectFunctionCall1(namein, CStringGetDatum(extName));
    values[Anum_pg_extension_extowner - 1] = ObjectIdGetDatum(extOwner);
    values[Anum_pg_extension_extnamespace - 1] = ObjectIdGetDatum(schemaOid);
    values[Anum_pg_extension_extrelocatable - 1] = BoolGetDatum(relocatable);
    values[Anum_pg_extension_extversion - 1] = CStringGetTextDatum(extVersion);
 
    if (extConfig == PointerGetDatum(NULL))
        nulls[Anum_pg_extension_extconfig - 1] = true;
    else
        values[Anum_pg_extension_extconfig - 1] = extConfig;
 
    if (extCondition == PointerGetDatum(NULL))
        nulls[Anum_pg_extension_extcondition - 1] = true;
    else
        values[Anum_pg_extension_extcondition - 1] = extCondition;
 
    tuple = heap_form_tuple(rel->rd_att, values, nulls);
 
    CatalogTupleInsert(rel, tuple);
 
    heap_freetuple(tuple);
    table_close(rel, RowExclusiveLock);
 
    /*
     * Record dependencies on owner, schema, and prerequisite extensions
     */
    recordDependencyOnOwner(ExtensionRelationId, extensionOid, extOwner);
 
    refobjs = new_object_addresses();
 
    ObjectAddressSet(myself, ExtensionRelationId, extensionOid);
 
    ObjectAddressSet(nsp, NamespaceRelationId, schemaOid);
    add_exact_object_address(&nsp, refobjs);
 
    foreach(lc, requiredExtensions)
    {
        Oid         reqext = lfirst_oid(lc);
        ObjectAddress otherext;
 
        ObjectAddressSet(otherext, ExtensionRelationId, reqext);
        add_exact_object_address(&otherext, refobjs);
    }
 
    /* Record all of them (this includes duplicate elimination) */
    record_object_address_dependencies(&myself, refobjs, DEPENDENCY_NORMAL);
    free_object_addresses(refobjs);
 
    /* Post creation hook for new extension */
    InvokeObjectPostCreateHook(ExtensionRelationId, extensionOid, 0);
 
    return myself;
}

References add_exact_object_address(), BoolGetDatum(), CatalogTupleInsert(), CStringGetDatum(), CStringGetTextDatum, DEPENDENCY_NORMAL, DirectFunctionCall1, free_object_addresses(), GetNewOidWithIndex(), heap_form_tuple(), heap_freetuple(), InvokeObjectPostCreateHook, lfirst_oid, namein(), new_object_addresses(), ObjectAddressSet, ObjectIdGetDatum(), PointerGetDatum(), RelationData::rd_att, record_object_address_dependencies(), recordDependencyOnOwner(), RowExclusiveLock, table_close(), table_open(), and values.

Referenced by binary_upgrade_create_empty_extension(), and CreateExtensionInternal().

is_extension_control_filename()

static bool is_extension_control_filename ( const char *  filename )

static

Definition at line 359 of file extension.c.

{
    const char *extension = strrchr(filename, '.');
 
    return (extension != NULL) && (strcmp(extension, ".control") == 0);
}

References filename.

Referenced by extension_file_exists(), pg_available_extension_versions(), and pg_available_extensions().

is_extension_script_filename()

static bool is_extension_script_filename ( const char *  filename )

static

Definition at line 367 of file extension.c.

{
    const char *extension = strrchr(filename, '.');
 
    return (extension != NULL) && (strcmp(extension, ".sql") == 0);
}

References filename.

Referenced by get_ext_ver_list().

parse_extension_control_file()

static void parse_extension_control_file ( ExtensionControlFile *  control, const char *  version  )

static

Definition at line 475 of file extension.c.

{
    char       *filename;
    FILE       *file;
    ConfigVariable *item,
               *head = NULL,
               *tail = NULL;
 
    /*
     * Locate the file to read.  Auxiliary files are optional.
     */
    if (version)
        filename = get_extension_aux_control_filename(control, version);
    else
        filename = get_extension_control_filename(control->name);
 
    if ((file = AllocateFile(filename, "r")) == NULL)
    {
        if (errno == ENOENT)
        {
            /* no complaint for missing auxiliary file */
            if (version)
            {
                pfree(filename);
                return;
            }
 
            /* missing control file indicates extension is not installed */
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("extension \"%s\" is not available", control->name),
                     errdetail("Could not open extension control file \"%s\": %m.",
                               filename),
                     errhint("The extension must first be installed on the system where PostgreSQL is running.")));
        }
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open extension control file \"%s\": %m",
                        filename)));
    }
 
    /*
     * Parse the file content, using GUC's file parsing code.  We need not
     * check the return value since any errors will be thrown at ERROR level.
     */
    (void) ParseConfigFp(file, filename, CONF_FILE_START_DEPTH, ERROR,
                         &head, &tail);
 
    FreeFile(file);
 
    /*
     * Convert the ConfigVariable list into ExtensionControlFile entries.
     */
    for (item = head; item != NULL; item = item->next)
    {
        if (strcmp(item->name, "directory") == 0)
        {
            if (version)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("parameter \"%s\" cannot be set in a secondary extension control file",
                                item->name)));
 
            control->directory = pstrdup(item->value);
        }
        else if (strcmp(item->name, "default_version") == 0)
        {
            if (version)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("parameter \"%s\" cannot be set in a secondary extension control file",
                                item->name)));
 
            control->default_version = pstrdup(item->value);
        }
        else if (strcmp(item->name, "module_pathname") == 0)
        {
            control->module_pathname = pstrdup(item->value);
        }
        else if (strcmp(item->name, "comment") == 0)
        {
            control->comment = pstrdup(item->value);
        }
        else if (strcmp(item->name, "schema") == 0)
        {
            control->schema = pstrdup(item->value);
        }
        else if (strcmp(item->name, "relocatable") == 0)
        {
            if (!parse_bool(item->value, &control->relocatable))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("parameter \"%s\" requires a Boolean value",
                                item->name)));
        }
        else if (strcmp(item->name, "superuser") == 0)
        {
            if (!parse_bool(item->value, &control->superuser))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("parameter \"%s\" requires a Boolean value",
                                item->name)));
        }
        else if (strcmp(item->name, "trusted") == 0)
        {
            if (!parse_bool(item->value, &control->trusted))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("parameter \"%s\" requires a Boolean value",
                                item->name)));
        }
        else if (strcmp(item->name, "encoding") == 0)
        {
            control->encoding = pg_valid_server_encoding(item->value);
            if (control->encoding < 0)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_OBJECT),
                         errmsg("\"%s\" is not a valid encoding name",
                                item->value)));
        }
        else if (strcmp(item->name, "requires") == 0)
        {
            /* Need a modifiable copy of string */
            char       *rawnames = pstrdup(item->value);
 
            /* Parse string into list of identifiers */
            if (!SplitIdentifierString(rawnames, ',', &control->requires))
            {
                /* syntax error in name list */
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("parameter \"%s\" must be a list of extension names",
                                item->name)));
            }
        }
        else if (strcmp(item->name, "no_relocate") == 0)
        {
            /* Need a modifiable copy of string */
            char       *rawnames = pstrdup(item->value);
 
            /* Parse string into list of identifiers */
            if (!SplitIdentifierString(rawnames, ',', &control->no_relocate))
            {
                /* syntax error in name list */
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("parameter \"%s\" must be a list of extension names",
                                item->name)));
            }
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("unrecognized parameter \"%s\" in file \"%s\"",
                            item->name, filename)));
    }
 
    FreeConfigVariables(head);
 
    if (control->relocatable && control->schema != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("parameter \"schema\" cannot be specified when \"relocatable\" is true")));
 
    pfree(filename);
}

References AllocateFile(), ExtensionControlFile::comment, CONF_FILE_START_DEPTH, ExtensionControlFile::default_version, ExtensionControlFile::directory, ExtensionControlFile::encoding, ereport, errcode(), errcode_for_file_access(), errdetail(), errhint(), errmsg(), ERROR, filename, FreeConfigVariables(), FreeFile(), get_extension_aux_control_filename(), get_extension_control_filename(), ExtensionControlFile::module_pathname, ExtensionControlFile::name, ConfigVariable::name, ConfigVariable::next, ExtensionControlFile::no_relocate, parse_bool(), ParseConfigFp(), pfree(), pg_valid_server_encoding(), pstrdup(), ExtensionControlFile::relocatable, ExtensionControlFile::requires, ExtensionControlFile::schema, SplitIdentifierString(), ExtensionControlFile::superuser, ExtensionControlFile::trusted, and ConfigVariable::value.

Referenced by read_extension_aux_control_file(), and read_extension_control_file().

pg_available_extension_versions()

Datum pg_available_extension_versions

(

PG_FUNCTION_ARGS

)

Definition at line 2065 of file extension.c.

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    char       *location;
    DIR        *dir;
    struct dirent *de;
 
    /* Build tuplestore to hold the result rows */
    InitMaterializedSRF(fcinfo, 0);
 
    location = get_extension_control_directory();
    dir = AllocateDir(location);
 
    /*
     * If the control directory doesn't exist, we want to silently return an
     * empty set.  Any other error will be reported by ReadDir.
     */
    if (dir == NULL && errno == ENOENT)
    {
        /* do nothing */
    }
    else
    {
        while ((de = ReadDir(dir, location)) != NULL)
        {
            ExtensionControlFile *control;
            char       *extname;
 
            if (!is_extension_control_filename(de->d_name))
                continue;
 
            /* extract extension name from 'name.control' filename */
            extname = pstrdup(de->d_name);
            *strrchr(extname, '.') = '\0';
 
            /* ignore it if it's an auxiliary control file */
            if (strstr(extname, "--"))
                continue;
 
            /* read the control file */
            control = read_extension_control_file(extname);
 
            /* scan extension's script directory for install scripts */
            get_available_versions_for_extension(control, rsinfo->setResult,
                                                 rsinfo->setDesc);
        }
 
        FreeDir(dir);
    }
 
    return (Datum) 0;
}

References AllocateDir(), FreeDir(), get_available_versions_for_extension(), get_extension_control_directory(), InitMaterializedSRF(), is_extension_control_filename(), pstrdup(), read_extension_control_file(), ReadDir(), ReturnSetInfo::setDesc, and ReturnSetInfo::setResult.

pg_available_extensions()

Datum pg_available_extensions

(

PG_FUNCTION_ARGS

)

Definition at line 1985 of file extension.c.

{
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    char       *location;
    DIR        *dir;
    struct dirent *de;
 
    /* Build tuplestore to hold the result rows */
    InitMaterializedSRF(fcinfo, 0);
 
    location = get_extension_control_directory();
    dir = AllocateDir(location);
 
    /*
     * If the control directory doesn't exist, we want to silently return an
     * empty set.  Any other error will be reported by ReadDir.
     */
    if (dir == NULL && errno == ENOENT)
    {
        /* do nothing */
    }
    else
    {
        while ((de = ReadDir(dir, location)) != NULL)
        {
            ExtensionControlFile *control;
            char       *extname;
            Datum       values[3];
            bool        nulls[3];
 
            if (!is_extension_control_filename(de->d_name))
                continue;
 
            /* extract extension name from 'name.control' filename */
            extname = pstrdup(de->d_name);
            *strrchr(extname, '.') = '\0';
 
            /* ignore it if it's an auxiliary control file */
            if (strstr(extname, "--"))
                continue;
 
            control = read_extension_control_file(extname);
 
            memset(values, 0, sizeof(values));
            memset(nulls, 0, sizeof(nulls));
 
            /* name */
            values[0] = DirectFunctionCall1(namein,
                                            CStringGetDatum(control->name));
            /* default_version */
            if (control->default_version == NULL)
                nulls[1] = true;
            else
                values[1] = CStringGetTextDatum(control->default_version);
            /* comment */
            if (control->comment == NULL)
                nulls[2] = true;
            else
                values[2] = CStringGetTextDatum(control->comment);
 
            tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                                 values, nulls);
        }
 
        FreeDir(dir);
    }
 
    return (Datum) 0;
}

References AllocateDir(), ExtensionControlFile::comment, CStringGetDatum(), CStringGetTextDatum, ExtensionControlFile::default_version, DirectFunctionCall1, FreeDir(), get_extension_control_directory(), InitMaterializedSRF(), is_extension_control_filename(), ExtensionControlFile::name, namein(), pstrdup(), read_extension_control_file(), ReadDir(), ReturnSetInfo::setDesc, ReturnSetInfo::setResult, tuplestore_putvalues(), and values.

pg_extension_config_dump()

Datum pg_extension_config_dump

(

PG_FUNCTION_ARGS

)

Definition at line 2401 of file extension.c.

{
    Oid         tableoid = PG_GETARG_OID(0);
    text       *wherecond = PG_GETARG_TEXT_PP(1);
    char       *tablename;
    Relation    extRel;
    ScanKeyData key[1];
    SysScanDesc extScan;
    HeapTuple   extTup;
    Datum       arrayDatum;
    Datum       elementDatum;
    int         arrayLength;
    int         arrayIndex;
    bool        isnull;
    Datum       repl_val[Natts_pg_extension];
    bool        repl_null[Natts_pg_extension];
    bool        repl_repl[Natts_pg_extension];
    ArrayType  *a;
 
    /*
     * We only allow this to be called from an extension's SQL script. We
     * shouldn't need any permissions check beyond that.
     */
    if (!creating_extension)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("%s can only be called from an SQL script executed by CREATE EXTENSION",
                        "pg_extension_config_dump()")));
 
    /*
     * Check that the table exists and is a member of the extension being
     * created.  This ensures that we don't need to register an additional
     * dependency to protect the extconfig entry.
     */
    tablename = get_rel_name(tableoid);
    if (tablename == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_TABLE),
                 errmsg("OID %u does not refer to a table", tableoid)));
    if (getExtensionOfObject(RelationRelationId, tableoid) !=
        CurrentExtensionObject)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("table \"%s\" is not a member of the extension being created",
                        tablename)));
 
    /*
     * Add the table OID and WHERE condition to the extension's extconfig and
     * extcondition arrays.
     *
     * If the table is already in extconfig, treat this as an update of the
     * WHERE condition.
     */
 
    /* Find the pg_extension tuple */
    extRel = table_open(ExtensionRelationId, RowExclusiveLock);
 
    ScanKeyInit(&key[0],
                Anum_pg_extension_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(CurrentExtensionObject));
 
    extScan = systable_beginscan(extRel, ExtensionOidIndexId, true,
                                 NULL, 1, key);
 
    extTup = systable_getnext(extScan);
 
    if (!HeapTupleIsValid(extTup))  /* should not happen */
        elog(ERROR, "could not find tuple for extension %u",
             CurrentExtensionObject);
 
    memset(repl_val, 0, sizeof(repl_val));
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));
 
    /* Build or modify the extconfig value */
    elementDatum = ObjectIdGetDatum(tableoid);
 
    arrayDatum = heap_getattr(extTup, Anum_pg_extension_extconfig,
                              RelationGetDescr(extRel), &isnull);
    if (isnull)
    {
        /* Previously empty extconfig, so build 1-element array */
        arrayLength = 0;
        arrayIndex = 1;
 
        a = construct_array_builtin(&elementDatum, 1, OIDOID);
    }
    else
    {
        /* Modify or extend existing extconfig array */
        Oid        *arrayData;
        int         i;
 
        a = DatumGetArrayTypeP(arrayDatum);
 
        arrayLength = ARR_DIMS(a)[0];
        if (ARR_NDIM(a) != 1 ||
            ARR_LBOUND(a)[0] != 1 ||
            arrayLength < 0 ||
            ARR_HASNULL(a) ||
            ARR_ELEMTYPE(a) != OIDOID)
            elog(ERROR, "extconfig is not a 1-D Oid array");
        arrayData = (Oid *) ARR_DATA_PTR(a);
 
        arrayIndex = arrayLength + 1;   /* set up to add after end */
 
        for (i = 0; i < arrayLength; i++)
        {
            if (arrayData[i] == tableoid)
            {
                arrayIndex = i + 1; /* replace this element instead */
                break;
            }
        }
 
        a = array_set(a, 1, &arrayIndex,
                      elementDatum,
                      false,
                      -1 /* varlena array */ ,
                      sizeof(Oid) /* OID's typlen */ ,
                      true /* OID's typbyval */ ,
                      TYPALIGN_INT /* OID's typalign */ );
    }
    repl_val[Anum_pg_extension_extconfig - 1] = PointerGetDatum(a);
    repl_repl[Anum_pg_extension_extconfig - 1] = true;
 
    /* Build or modify the extcondition value */
    elementDatum = PointerGetDatum(wherecond);
 
    arrayDatum = heap_getattr(extTup, Anum_pg_extension_extcondition,
                              RelationGetDescr(extRel), &isnull);
    if (isnull)
    {
        if (arrayLength != 0)
            elog(ERROR, "extconfig and extcondition arrays do not match");
 
        a = construct_array_builtin(&elementDatum, 1, TEXTOID);
    }
    else
    {
        a = DatumGetArrayTypeP(arrayDatum);
 
        if (ARR_NDIM(a) != 1 ||
            ARR_LBOUND(a)[0] != 1 ||
            ARR_HASNULL(a) ||
            ARR_ELEMTYPE(a) != TEXTOID)
            elog(ERROR, "extcondition is not a 1-D text array");
        if (ARR_DIMS(a)[0] != arrayLength)
            elog(ERROR, "extconfig and extcondition arrays do not match");
 
        /* Add or replace at same index as in extconfig */
        a = array_set(a, 1, &arrayIndex,
                      elementDatum,
                      false,
                      -1 /* varlena array */ ,
                      -1 /* TEXT's typlen */ ,
                      false /* TEXT's typbyval */ ,
                      TYPALIGN_INT /* TEXT's typalign */ );
    }
    repl_val[Anum_pg_extension_extcondition - 1] = PointerGetDatum(a);
    repl_repl[Anum_pg_extension_extcondition - 1] = true;
 
    extTup = heap_modify_tuple(extTup, RelationGetDescr(extRel),
                               repl_val, repl_null, repl_repl);
 
    CatalogTupleUpdate(extRel, &extTup->t_self, extTup);
 
    systable_endscan(extScan);
 
    table_close(extRel, RowExclusiveLock);
 
    PG_RETURN_VOID();
}

References a, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_LBOUND, ARR_NDIM, array_set(), BTEqualStrategyNumber, CatalogTupleUpdate(), construct_array_builtin(), creating_extension, CurrentExtensionObject, DatumGetArrayTypeP, elog(), ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), ERROR, get_rel_name(), getExtensionOfObject(), heap_getattr(), heap_modify_tuple(), HeapTupleIsValid, i, sort-test::key, ObjectIdGetDatum(), PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_VOID, PointerGetDatum(), RelationGetDescr, RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

pg_extension_update_paths()

Datum pg_extension_update_paths

(

PG_FUNCTION_ARGS

)

Definition at line 2316 of file extension.c.

{
    Name        extname = PG_GETARG_NAME(0);
    ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
    List       *evi_list;
    ExtensionControlFile *control;
    ListCell   *lc1;
 
    /* Check extension name validity before any filesystem access */
    check_valid_extension_name(NameStr(*extname));
 
    /* Build tuplestore to hold the result rows */
    InitMaterializedSRF(fcinfo, 0);
 
    /* Read the extension's control file */
    control = read_extension_control_file(NameStr(*extname));
 
    /* Extract the version update graph from the script directory */
    evi_list = get_ext_ver_list(control);
 
    /* Iterate over all pairs of versions */
    foreach(lc1, evi_list)
    {
        ExtensionVersionInfo *evi1 = (ExtensionVersionInfo *) lfirst(lc1);
        ListCell   *lc2;
 
        foreach(lc2, evi_list)
        {
            ExtensionVersionInfo *evi2 = (ExtensionVersionInfo *) lfirst(lc2);
            List       *path;
            Datum       values[3];
            bool        nulls[3];
 
            if (evi1 == evi2)
                continue;
 
            /* Find shortest path from evi1 to evi2 */
            path = find_update_path(evi_list, evi1, evi2, false, true);
 
            /* Emit result row */
            memset(values, 0, sizeof(values));
            memset(nulls, 0, sizeof(nulls));
 
            /* source */
            values[0] = CStringGetTextDatum(evi1->name);
            /* target */
            values[1] = CStringGetTextDatum(evi2->name);
            /* path */
            if (path == NIL)
                nulls[2] = true;
            else
            {
                StringInfoData pathbuf;
                ListCell   *lcv;
 
                initStringInfo(&pathbuf);
                /* The path doesn't include start vertex, but show it */
                appendStringInfoString(&pathbuf, evi1->name);
                foreach(lcv, path)
                {
                    char       *versionName = (char *) lfirst(lcv);
 
                    appendStringInfoString(&pathbuf, "--");
                    appendStringInfoString(&pathbuf, versionName);
                }
                values[2] = CStringGetTextDatum(pathbuf.data);
                pfree(pathbuf.data);
            }
 
            tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
                                 values, nulls);
        }
    }
 
    return (Datum) 0;
}

References appendStringInfoString(), check_valid_extension_name(), CStringGetTextDatum, StringInfoData::data, find_update_path(), get_ext_ver_list(), InitMaterializedSRF(), initStringInfo(), lfirst, ExtensionVersionInfo::name, NameStr, NIL, pfree(), PG_GETARG_NAME, read_extension_control_file(), ReturnSetInfo::setDesc, ReturnSetInfo::setResult, tuplestore_putvalues(), and values.

read_extension_aux_control_file()

static ExtensionControlFile* read_extension_aux_control_file ( const ExtensionControlFile *  pcontrol, const char *  version  )

static

Definition at line 676 of file extension.c.

{
    ExtensionControlFile *acontrol;
 
    /*
     * Flat-copy the struct.  Pointer fields share values with original.
     */
    acontrol = (ExtensionControlFile *) palloc(sizeof(ExtensionControlFile));
    memcpy(acontrol, pcontrol, sizeof(ExtensionControlFile));
 
    /*
     * Parse the auxiliary control file, overwriting struct fields
     */
    parse_extension_control_file(acontrol, version);
 
    return acontrol;
}

References palloc(), and parse_extension_control_file().

Referenced by ApplyExtensionUpdates(), CreateExtensionInternal(), and get_available_versions_for_extension().

read_extension_control_file()

static ExtensionControlFile* read_extension_control_file ( const char *  extname )

static

Definition at line 647 of file extension.c.

{
    ExtensionControlFile *control;
 
    /*
     * Set up default values.  Pointer fields are initially null.
     */
    control = (ExtensionControlFile *) palloc0(sizeof(ExtensionControlFile));
    control->name = pstrdup(extname);
    control->relocatable = false;
    control->superuser = true;
    control->trusted = false;
    control->encoding = -1;
 
    /*
     * Parse the primary control file.
     */
    parse_extension_control_file(control, NULL);
 
    return control;
}

References ExtensionControlFile::encoding, ExtensionControlFile::name, palloc0(), parse_extension_control_file(), pstrdup(), ExtensionControlFile::relocatable, ExtensionControlFile::superuser, and ExtensionControlFile::trusted.

Referenced by AlterExtensionNamespace(), CreateExtensionInternal(), ExecAlterExtensionStmt(), pg_available_extension_versions(), pg_available_extensions(), and pg_extension_update_paths().

read_extension_script_file()

static char* read_extension_script_file ( const ExtensionControlFile *  control, const char *  filename  )

static

Definition at line 699 of file extension.c.

{
    int         src_encoding;
    char       *src_str;
    char       *dest_str;
    int         len;
 
    src_str = read_whole_file(filename, &len);
 
    /* use database encoding if not given */
    if (control->encoding < 0)
        src_encoding = GetDatabaseEncoding();
    else
        src_encoding = control->encoding;
 
    /* make sure that source string is valid in the expected encoding */
    (void) pg_verify_mbstr(src_encoding, src_str, len, false);
 
    /*
     * Convert the encoding to the database encoding. read_whole_file
     * null-terminated the string, so if no conversion happens the string is
     * valid as is.
     */
    dest_str = pg_any_to_server(src_str, len, src_encoding);
 
    return dest_str;
}

References ExtensionControlFile::encoding, filename, GetDatabaseEncoding(), len, pg_any_to_server(), pg_verify_mbstr(), and read_whole_file().

Referenced by execute_extension_script().

read_whole_file()

static char * read_whole_file ( const char *  filename, int *  length  )

static

Definition at line 3435 of file extension.c.

{
    char       *buf;
    FILE       *file;
    size_t      bytes_to_read;
    struct stat fst;
 
    if (stat(filename, &fst) < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not stat file \"%s\": %m", filename)));
 
    if (fst.st_size > (MaxAllocSize - 1))
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("file \"%s\" is too large", filename)));
    bytes_to_read = (size_t) fst.st_size;
 
    if ((file = AllocateFile(filename, PG_BINARY_R)) == NULL)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\" for reading: %m",
                        filename)));
 
    buf = (char *) palloc(bytes_to_read + 1);
 
    *length = fread(buf, 1, bytes_to_read, file);
 
    if (ferror(file))
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not read file \"%s\": %m", filename)));
 
    FreeFile(file);
 
    buf[*length] = '\0';
    return buf;
}

References AllocateFile(), buf, ereport, errcode(), errcode_for_file_access(), errmsg(), ERROR, filename, FreeFile(), if(), MaxAllocSize, palloc(), PG_BINARY_R, stat::st_size, and stat.

Referenced by read_extension_script_file().

RemoveExtensionById()

void RemoveExtensionById

(

Oid

extId

)

Definition at line 1931 of file extension.c.

{
    Relation    rel;
    SysScanDesc scandesc;
    HeapTuple   tuple;
    ScanKeyData entry[1];
 
    /*
     * Disallow deletion of any extension that's currently open for insertion;
     * else subsequent executions of recordDependencyOnCurrentExtension()
     * could create dangling pg_depend records that refer to a no-longer-valid
     * pg_extension OID.  This is needed not so much because we think people
     * might write "DROP EXTENSION foo" in foo's own script files, as because
     * errors in dependency management in extension script files could give
     * rise to cases where an extension is dropped as a result of recursing
     * from some contained object.  Because of that, we must test for the case
     * here, not at some higher level of the DROP EXTENSION command.
     */
    if (extId == CurrentExtensionObject)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("cannot drop extension \"%s\" because it is being modified",
                        get_extension_name(extId))));
 
    rel = table_open(ExtensionRelationId, RowExclusiveLock);
 
    ScanKeyInit(&entry[0],
                Anum_pg_extension_oid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(extId));
    scandesc = systable_beginscan(rel, ExtensionOidIndexId, true,
                                  NULL, 1, entry);
 
    tuple = systable_getnext(scandesc);
 
    /* We assume that there can be at most one matching tuple */
    if (HeapTupleIsValid(tuple))
        CatalogTupleDelete(rel, &tuple->t_self);
 
    systable_endscan(scandesc);
 
    table_close(rel, RowExclusiveLock);
}

References BTEqualStrategyNumber, CatalogTupleDelete(), CurrentExtensionObject, ereport, errcode(), errmsg(), ERROR, get_extension_name(), HeapTupleIsValid, ObjectIdGetDatum(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by doDeletion().

Variable Documentation

creating_extension

bool creating_extension = false

Definition at line 73 of file extension.c.

Referenced by checkMembershipInCurrentExtension(), CreateExtension(), EventTriggerAlterTableStart(), EventTriggerCollectAlterDefPrivs(), EventTriggerCollectAlterOpFam(), EventTriggerCollectAlterTSConfig(), EventTriggerCollectCreateOpClass(), EventTriggerCollectGrant(), EventTriggerCollectSimpleCommand(), ExecAlterExtensionStmt(), execute_extension_script(), findDependentObjects(), pg_extension_config_dump(), recordDependencyOnCurrentExtension(), and recordExtensionInitPriv().

CurrentExtensionObject

Oid CurrentExtensionObject = InvalidOid

Definition at line 74 of file extension.c.

Referenced by checkMembershipInCurrentExtension(), execute_extension_script(), findDependentObjects(), pg_extension_config_dump(), recordDependencyOnCurrentExtension(), and RemoveExtensionById().