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)
bool	extension_file_exists (const char *extensionName)
ObjectAddress	AlterExtensionNamespace (const char *extensionName, const char *newschema, Oid *oldschema)

Variables
PGDLLIMPORT bool	creating_extension
PGDLLIMPORT Oid	CurrentExtensionObject

Function Documentation

AlterExtensionNamespace()

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

Definition at line 2708 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;
 
        /*
         * 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, elog(), ereport, errcode(), errdetail(), errmsg(), ERROR, get_extension_oid(), get_namespace_name(), getExtensionOfObject(), getObjectDescription(), GETSTRUCT, GetUserId(), heap_copytuple(), HeapTupleIsValid, InvalidObjectAddress, InvalidOid, InvokeObjectPostAlterHook, sort-test::key, LookupCreationNamespace(), NameStr, new_object_addresses(), object_aclcheck(), OBJECT_EXTENSION, object_ownercheck(), OBJECT_SCHEMA, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, relation_close(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ExecAlterObjectSchemaStmt().

CreateExtension()

ObjectAddress CreateExtension	(	ParseState *	pstate,
		CreateExtensionStmt *	stmt
	)

Definition at line 1704 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(), CreateExtensionStmt::extname, get_extension_oid(), CreateExtensionStmt::if_not_exists, InvalidObjectAddress, InvalidOid, lfirst, NIL, NOTICE, and CreateExtensionStmt::options.

Referenced by ProcessUtilitySlow().

ExecAlterExtensionContentsStmt()

ObjectAddress ExecAlterExtensionContentsStmt	(	AlterExtensionContentsStmt *	stmt,
		ObjectAddress *	objAddr
	)

Definition at line 3195 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, AlterExtensionContentsStmt::action, Assert(), check_object_ownership(), deleteDependencyRecordsForClass(), DEPENDENCY_EXTENSION, elog(), ereport, errcode(), errmsg(), ERROR, extension_config_remove(), AlterExtensionContentsStmt::extname, get_extension_name(), get_extension_schema(), get_namespace_name(), get_object_address(), getExtensionOfObject(), getObjectDescription(), GetUserId(), InvokeObjectPostAlterHook, makeString(), NoLock, AlterExtensionContentsStmt::object, OBJECT_DATABASE, OBJECT_EXTENSION, OBJECT_INDEX, object_ownercheck(), OBJECT_PUBLICATION, OBJECT_ROLE, OBJECT_STATISTIC_EXT, OBJECT_SUBSCRIPTION, OBJECT_TABLESPACE, ObjectAddress::objectId, AlterExtensionContentsStmt::objtype, OidIsValid, recordDependencyOn(), recordExtObjInitPriv(), relation_close(), removeExtObjInitPriv(), and ShareUpdateExclusiveLock.

Referenced by ProcessUtilitySlow().

ExecAlterExtensionStmt()

ObjectAddress ExecAlterExtensionStmt	(	ParseState *	pstate,
		AlterExtensionStmt *	stmt
	)

Definition at line 2890 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(), AlterExtensionStmt::extname, GETSTRUCT, GetUserId(), heap_getattr(), HeapTupleIsValid, identify_update_path(), InvalidObjectAddress, sort-test::key, lfirst, NOTICE, OBJECT_EXTENSION, object_ownercheck(), ObjectAddressSet, AlterExtensionStmt::options, read_extension_control_file(), RelationGetDescr, ScanKeyInit(), 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

)

Definition at line 2196 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().

get_extension_name()

char* get_extension_name

(

Oid

ext_oid

)

Definition at line 187 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 checkMembershipInCurrentExtension(), ExecAlterExtensionContentsStmt(), getObjectDescription(), getObjectIdentityParts(), recordDependencyOnCurrentExtension(), and RemoveExtensionById().

get_extension_oid()

Oid get_extension_oid	(	const char *	extname,
		bool	missing_ok
	)

Definition at line 142 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().

InsertExtensionTuple()

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

Definition at line 1802 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().

RemoveExtensionById()

void RemoveExtensionById

(

Oid

extId

)

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

PGDLLIMPORT bool creating_extension

extern

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

PGDLLIMPORT Oid CurrentExtensionObject

extern

Definition at line 74 of file extension.c.

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