extension.h File Reference

#include "catalog/objectaddress.h"
#include "parser/parse_node.h"

Include dependency graph for extension.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
ObjectAddress	CreateExtension (ParseState *pstate, CreateExtensionStmt *stmt)
void	RemoveExtensionById (Oid extId)
ObjectAddress	InsertExtensionTuple (const char *extName, Oid extOwner, Oid schemaOid, bool relocatable, const char *extVersion, Datum extConfig, Datum extCondition, List *requiredExtensions)
ObjectAddress	ExecAlterExtensionStmt (ParseState *pstate, AlterExtensionStmt *stmt)
ObjectAddress	ExecAlterExtensionContentsStmt (AlterExtensionContentsStmt *stmt, ObjectAddress *objAddr)
Oid	get_extension_oid (const char *extname, bool missing_ok)
char *	get_extension_name (Oid ext_oid)
Oid	get_extension_schema (Oid ext_oid)
bool	extension_file_exists (const char *extensionName)
ObjectAddress	AlterExtensionNamespace (const char *extensionName, const char *newschema, Oid *oldschema)

Variables
PGDLLIMPORT char *	Extension_control_path
PGDLLIMPORT bool	creating_extension
PGDLLIMPORT Oid	CurrentExtensionObject

Function Documentation

AlterExtensionNamespace()

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

extern

Definition at line 3122 of file extension.c.

{
    Oid         extensionOid;
    Oid         nspOid;
    Oid         oldNspOid;
    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();
 
    /* store the OID of the namespace to-be-changed */
    oldNspOid = extForm->extnamespace;
 
    /*
     * 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);
 
        /*
         * If not all the objects had the same old namespace (ignoring any
         * that are not in namespaces or are dependent types), 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 dependency to point to the new schema */
    if (changeDependencyFor(ExtensionRelationId, extensionOid,
                            NamespaceRelationId, oldNspOid, nspOid) != 1)
        elog(ERROR, "could not change schema dependency for extension %s",
             NameStr(extForm->extname));
 
    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(), DEPENDENCY_EXTENSION, DEPENDENCY_NORMAL, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, fb(), get_extension_name(), get_extension_oid(), get_namespace_name(), getExtensionOfObject(), getObjectDescription(), GETSTRUCT(), GetUserId(), heap_copytuple(), HeapTupleIsValid, InvalidObjectAddress, InvalidOid, InvokeObjectPostAlterHook, lfirst, LookupCreationNamespace(), NameStr, new_object_addresses(), object_aclcheck(), OBJECT_EXTENSION, object_ownercheck(), OBJECT_SCHEMA, ObjectAddressSet, ObjectIdGetDatum(), read_extension_control_file(), relation_close(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), and table_open().

Referenced by ExecAlterObjectSchemaStmt().

CreateExtension()

ObjectAddress CreateExtension ( ParseState *  pstate, CreateExtensionStmt *  stmt  )

extern

Definition at line 2013 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(), elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, errorConflictingDefElem(), fb(), get_extension_oid(), InvalidObjectAddress, InvalidOid, lfirst, NIL, NOTICE, and stmt.

Referenced by ProcessUtilitySlow().

ExecAlterExtensionContentsStmt()

ObjectAddress ExecAlterExtensionContentsStmt ( AlterExtensionContentsStmt *  stmt, ObjectAddress *  objAddr  )

extern

Definition at line 3642 of file extension.c.

{
    ObjectAddress extension;
    ObjectAddress object;
    Relation    relation;
 
    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);
 
    /* Do the update, recursing to any dependent objects */
    ExecAlterExtensionContentsRecurse(stmt, extension, object);
 
    /* Finish up */
    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(), ereport, errcode(), errmsg(), ERROR, ExecAlterExtensionContentsRecurse(), fb(), get_object_address(), GetUserId(), InvokeObjectPostAlterHook, makeString(), NoLock, OBJECT_DATABASE, OBJECT_EXTENSION, OBJECT_INDEX, object_ownercheck(), OBJECT_PUBLICATION, OBJECT_ROLE, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABLESPACE, relation_close(), ShareUpdateExclusiveLock, and stmt.

Referenced by ProcessUtilitySlow().

ExecAlterExtensionStmt()

ObjectAddress ExecAlterExtensionStmt ( ParseState *  pstate, AlterExtensionStmt *  stmt  )

extern

Definition at line 3337 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(), BTEqualStrategyNumber, check_valid_version_name(), creating_extension, CStringGetDatum(), DatumGetTextPP, ExtensionControlFile::default_version, elog, ereport, errcode(), errmsg(), ERROR, errorConflictingDefElem(), fb(), GETSTRUCT(), GetUserId(), heap_getattr(), HeapTupleIsValid, identify_update_path(), InvalidObjectAddress, 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().

extension_file_exists()

bool extension_file_exists ( const char *  extensionName )

extern

Definition at line 2551 of file extension.c.

{
    bool        result = false;
    List       *locations;
    DIR        *dir;
    struct dirent *de;
 
    locations = get_extension_control_directories();
 
    foreach_ptr(char, location, locations)
    {
        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);
        }
        if (result)
            break;
    }
 
    return result;
}

References AllocateDir(), fb(), foreach_ptr, FreeDir(), get_extension_control_directories(), is_extension_control_filename(), pstrdup(), and ReadDir().

Referenced by CreateFunction(), and ExecuteDoStmt().

get_extension_name()

char * get_extension_name ( Oid  ext_oid )

extern

Definition at line 228 of file extension.c.

{
    char       *result;
    HeapTuple   tuple;
 
    tuple = SearchSysCache1(EXTENSIONOID, ObjectIdGetDatum(ext_oid));
 
    if (!HeapTupleIsValid(tuple))
        return NULL;
 
    result = pstrdup(NameStr(((Form_pg_extension) GETSTRUCT(tuple))->extname));
    ReleaseSysCache(tuple);
 
    return result;
}

References fb(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), pstrdup(), ReleaseSysCache(), and SearchSysCache1().

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

get_extension_oid()

Oid get_extension_oid ( const char *  extname, bool  missing_ok  )

extern

Definition at line 206 of file extension.c.

{
    Oid         result;
 
    result = GetSysCacheOid1(EXTENSIONNAME, Anum_pg_extension_oid,
                             CStringGetDatum(extname));
 
    if (!OidIsValid(result) && !missing_ok)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("extension \"%s\" does not exist",
                        extname)));
 
    return result;
}

References CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, fb(), GetSysCacheOid1, and OidIsValid.

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 )

extern

Definition at line 250 of file extension.c.

{
    Oid         result;
    HeapTuple   tuple;
 
    tuple = SearchSysCache1(EXTENSIONOID, ObjectIdGetDatum(ext_oid));
 
    if (!HeapTupleIsValid(tuple))
        return InvalidOid;
 
    result = ((Form_pg_extension) GETSTRUCT(tuple))->extnamespace;
    ReleaseSysCache(tuple);
 
    return result;
}

References fb(), GETSTRUCT(), HeapTupleIsValid, InvalidOid, ObjectIdGetDatum(), ReleaseSysCache(), and SearchSysCache1().

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

InsertExtensionTuple()

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

extern

Definition at line 2111 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, fb(), 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().

RemoveExtensionById()

void RemoveExtensionById ( Oid  extId )

extern

Definition at line 2199 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, fb(), 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

PGDLLIMPORT bool creating_extension

extern

Definition at line 77 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

PGDLLIMPORT Oid CurrentExtensionObject

extern

Definition at line 78 of file extension.c.

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

Extension_control_path

PGDLLIMPORT char* Extension_control_path

extern

Definition at line 74 of file extension.c.

Referenced by get_extension_control_directories().