#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:

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 2774 of file extension.c.

References AccessShareLock, ACL_CREATE, aclcheck_error(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, AlterObjectNamespace_oid(), BTEqualStrategyNumber, CatalogTupleUpdate(), changeDependencyFor(), ObjectAddress::classId, DEPENDENCY_EXTENSION, DependReferenceIndexId, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, ExtensionOidIndexId, 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_EXTENSION, OBJECT_SCHEMA, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, pg_extension_ownercheck(), pg_namespace_aclcheck(), relation_close(), RowExclusiveLock, ScanKeyInit(), systable_beginscan(), systable_endscan(), systable_getnext(), HeapTupleData::t_self, table_close(), and table_open().

Referenced by ExecAlterObjectSchemaStmt().

 {
     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 (!pg_extension_ownercheck(extensionOid, GetUserId()))
         aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EXTENSION,
                        extensionName);
 
     /* Permission check: must have creation rights in target namespace */
     aclresult = pg_namespace_aclcheck(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),
                                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;
 }

◆ CreateExtension()

ObjectAddress CreateExtension	(	ParseState *	pstate,
		CreateExtensionStmt *	stmt
	)

Definition at line 1667 of file extension.c.

References check_valid_extension_name(), CreateExtensionInternal(), creating_extension, defGetBoolean(), defGetString(), DefElem::defname, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, CreateExtensionStmt::extname, get_extension_oid(), CreateExtensionStmt::if_not_exists, InvalidObjectAddress, InvalidOid, lfirst, DefElem::location, NIL, NOTICE, CreateExtensionStmt::options, and parser_errposition().

Referenced by ProcessUtilitySlow().

 {
     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)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             d_schema = defel;
             schemaName = defGetString(d_schema);
         }
         else if (strcmp(defel->defname, "new_version") == 0)
         {
             if (d_new_version)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             d_new_version = defel;
             versionName = defGetString(d_new_version);
         }
         else if (strcmp(defel->defname, "cascade") == 0)
         {
             if (d_cascade)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             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);
 }

◆ ExecAlterExtensionContentsStmt()

ObjectAddress ExecAlterExtensionContentsStmt	(	AlterExtensionContentsStmt *	stmt,
		ObjectAddress *	objAddr
	)

Definition at line 3264 of file extension.c.

References aclcheck_error(), ACLCHECK_NOT_OWNER, AlterExtensionContentsStmt::action, Assert, check_object_ownership(), ObjectAddress::classId, deleteDependencyRecordsForClass(), DEPENDENCY_EXTENSION, elog, ereport, errcode(), errmsg(), ERROR, extension_config_remove(), AlterExtensionContentsStmt::extname, get_extension_name(), get_extension_oid(), get_extension_schema(), get_namespace_name(), get_object_address(), getExtensionOfObject(), getObjectDescription(), GetUserId(), InvokeObjectPostAlterHook, NoLock, AlterExtensionContentsStmt::object, OBJECT_EXTENSION, ObjectAddress::objectId, ObjectAddress::objectSubId, AlterExtensionContentsStmt::objtype, OidIsValid, pg_extension_ownercheck(), recordDependencyOn(), recordExtObjInitPriv(), relation_close(), removeExtObjInitPriv(), and ShareUpdateExclusiveLock.

Referenced by ProcessUtilitySlow().

 {
     ObjectAddress extension;
     ObjectAddress object;
     Relation    relation;
     Oid         oldExtension;
 
     extension.classId = ExtensionRelationId;
     extension.objectId = get_extension_oid(stmt->extname, false);
     extension.objectSubId = 0;
 
     /* Permission check: must own extension */
     if (!pg_extension_ownercheck(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),
                             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),
                             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;
 }

◆ ExecAlterExtensionStmt()

ObjectAddress ExecAlterExtensionStmt	(	ParseState *	pstate,
		AlterExtensionStmt *	stmt
	)

Definition at line 2956 of file extension.c.

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, ExtensionNameIndexId, AlterExtensionStmt::extname, GETSTRUCT, GetUserId(), heap_getattr, HeapTupleIsValid, identify_update_path(), InvalidObjectAddress, sort-test::key, lfirst, DefElem::location, NOTICE, OBJECT_EXTENSION, ObjectAddressSet, AlterExtensionStmt::options, parser_errposition(), pg_extension_ownercheck(), read_extension_control_file(), RelationGetDescr, ScanKeyInit(), strVal, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), and text_to_cstring().

Referenced by ProcessUtilitySlow().

 {
     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 (!pg_extension_ownercheck(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)
                 ereport(ERROR,
                         (errcode(ERRCODE_SYNTAX_ERROR),
                          errmsg("conflicting or redundant options"),
                          parser_errposition(pstate, defel->location)));
             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;
 }

◆ extension_file_exists()

bool extension_file_exists ( const char * extensionName )

Definition at line 2224 of file extension.c.

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

Referenced by CreateFunction(), and ExecuteDoStmt().

 {
     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;
 }

◆ get_extension_name()

char* get_extension_name ( Oid ext_oid )

Definition at line 185 of file extension.c.

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

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

 {
     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;
 }

◆ get_extension_oid()

Oid get_extension_oid	(	const char *	extname,
		bool	missing_ok
	)

Definition at line 140 of file extension.c.

References AccessShareLock, BTEqualStrategyNumber, CStringGetDatum, ereport, errcode(), errmsg(), ERROR, ExtensionNameIndexId, 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(), ExecAlterExtensionContentsStmt(), ExtractExtensionList(), get_object_address_unqualified(), and get_required_extension().

 {
     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;
 }

◆ InsertExtensionTuple()

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

Definition at line 1774 of file extension.c.

References BoolGetDatum, CatalogTupleInsert(), ObjectAddress::classId, CStringGetDatum, CStringGetTextDatum, DEPENDENCY_NORMAL, DirectFunctionCall1, ExtensionOidIndexId, GetNewOidWithIndex(), heap_form_tuple(), heap_freetuple(), InvokeObjectPostCreateHook, lfirst_oid, namein(), ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, PointerGetDatum, RelationData::rd_att, recordDependencyOn(), recordDependencyOnOwner(), RowExclusiveLock, table_close(), table_open(), and values.

Referenced by binary_upgrade_create_empty_extension(), and CreateExtensionInternal().

 {
     Oid         extensionOid;
     Relation    rel;
     Datum       values[Natts_pg_extension];
     bool        nulls[Natts_pg_extension];
     HeapTuple   tuple;
     ObjectAddress myself;
     ObjectAddress nsp;
     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);
 
     myself.classId = ExtensionRelationId;
     myself.objectId = extensionOid;
     myself.objectSubId = 0;
 
     nsp.classId = NamespaceRelationId;
     nsp.objectId = schemaOid;
     nsp.objectSubId = 0;
 
     recordDependencyOn(&myself, &nsp, DEPENDENCY_NORMAL);
 
     foreach(lc, requiredExtensions)
     {
         Oid         reqext = lfirst_oid(lc);
         ObjectAddress otherext;
 
         otherext.classId = ExtensionRelationId;
         otherext.objectId = reqext;
         otherext.objectSubId = 0;
 
         recordDependencyOn(&myself, &otherext, DEPENDENCY_NORMAL);
     }
     /* Post creation hook for new extension */
     InvokeObjectPostCreateHook(ExtensionRelationId, extensionOid, 0);
 
     return myself;
 }

◆ RemoveExtensionById()

void RemoveExtensionById ( Oid extId )

Definition at line 1862 of file extension.c.

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

Referenced by doDeletion().

 {
     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);
 }

Variable Documentation

◆ creating_extension

PGDLLIMPORT bool creating_extension

Definition at line 71 of file extension.c.

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

◆ CurrentExtensionObject

PGDLLIMPORT Oid CurrentExtensionObject

Definition at line 72 of file extension.c.

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

Functions

Variables

Function Documentation

◆ AlterExtensionNamespace()

◆ CreateExtension()

◆ ExecAlterExtensionContentsStmt()

◆ ExecAlterExtensionStmt()

◆ extension_file_exists()

◆ get_extension_name()

◆ get_extension_oid()

◆ InsertExtensionTuple()

◆ RemoveExtensionById()

Variable Documentation

◆ creating_extension

◆ CurrentExtensionObject