#include "catalog/objectaddress.h"
#include "nodes/parsenodes.h"
#include "utils/array.h"

Include dependency graph for defrem.h:

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

Functions
void	RemoveObjects (DropStmt *stmt)

ObjectAddress	DefineIndex (Oid relationId, IndexStmt *stmt, Oid indexRelationId, bool is_alter_table, bool check_rights, bool check_not_in_use, bool skip_build, bool quiet)

Oid	ReindexIndex (RangeVar *indexRelation, int options)

Oid	ReindexTable (RangeVar *relation, int options)

void	ReindexMultipleTables (const char *objectName, ReindexObjectType objectKind, int options)

char *	makeObjectName (const char name1, const char name2, const char *label)

char *	ChooseRelationName (const char name1, const char name2, const char *label, Oid namespaceid)

bool	CheckIndexCompatible (Oid oldId, char accessMethodName, List attributeList, List *exclusionOpNames)

Oid	GetDefaultOpClass (Oid type_id, Oid am_id)

Oid	ResolveOpClass (List opclass, Oid attrType, char accessMethodName, Oid accessMethodId)

ObjectAddress	CreateFunction (ParseState pstate, CreateFunctionStmt stmt)

void	RemoveFunctionById (Oid funcOid)

void	SetFunctionReturnType (Oid funcOid, Oid newRetType)

void	SetFunctionArgType (Oid funcOid, int argIndex, Oid newArgType)

ObjectAddress	AlterFunction (ParseState pstate, AlterFunctionStmt stmt)

ObjectAddress	CreateCast (CreateCastStmt *stmt)

void	DropCastById (Oid castOid)

ObjectAddress	CreateTransform (CreateTransformStmt *stmt)

void	DropTransformById (Oid transformOid)

void	IsThereFunctionInNamespace (const char proname, int pronargs, oidvector proargtypes, Oid nspOid)

void	ExecuteDoStmt (DoStmt *stmt)

Oid	get_cast_oid (Oid sourcetypeid, Oid targettypeid, bool missing_ok)

Oid	get_transform_oid (Oid type_id, Oid lang_id, bool missing_ok)

void	interpret_function_parameter_list (ParseState pstate, List parameters, Oid languageOid, bool is_aggregate, oidvector parameterTypes, ArrayType allParameterTypes, ArrayType parameterModes, ArrayType parameterNames, List *parameterDefaults, Oid variadicArgType, Oid *requiredResultType)

ObjectAddress	DefineOperator (List names, List parameters)

void	RemoveOperatorById (Oid operOid)

ObjectAddress	AlterOperator (AlterOperatorStmt *stmt)

ObjectAddress	CreateStatistics (CreateStatsStmt *stmt)

void	RemoveStatisticsById (Oid statsOid)

void	UpdateStatisticsForTypeChange (Oid statsOid, Oid relationOid, int attnum, Oid oldColumnType, Oid newColumnType)

ObjectAddress	DefineAggregate (ParseState pstate, List name, List args, bool oldstyle, List parameters)

ObjectAddress	DefineOpClass (CreateOpClassStmt *stmt)

ObjectAddress	DefineOpFamily (CreateOpFamilyStmt *stmt)

Oid	AlterOpFamily (AlterOpFamilyStmt *stmt)

void	RemoveOpClassById (Oid opclassOid)

void	RemoveOpFamilyById (Oid opfamilyOid)

void	RemoveAmOpEntryById (Oid entryOid)

void	RemoveAmProcEntryById (Oid entryOid)

void	IsThereOpClassInNamespace (const char *opcname, Oid opcmethod, Oid opcnamespace)

void	IsThereOpFamilyInNamespace (const char *opfname, Oid opfmethod, Oid opfnamespace)

Oid	get_opclass_oid (Oid amID, List *opclassname, bool missing_ok)

Oid	get_opfamily_oid (Oid amID, List *opfamilyname, bool missing_ok)

ObjectAddress	DefineTSParser (List names, List parameters)

void	RemoveTSParserById (Oid prsId)

ObjectAddress	DefineTSDictionary (List names, List parameters)

void	RemoveTSDictionaryById (Oid dictId)

ObjectAddress	AlterTSDictionary (AlterTSDictionaryStmt *stmt)

ObjectAddress	DefineTSTemplate (List names, List parameters)

void	RemoveTSTemplateById (Oid tmplId)

ObjectAddress	DefineTSConfiguration (List names, List parameters, ObjectAddress *copied)

void	RemoveTSConfigurationById (Oid cfgId)

ObjectAddress	AlterTSConfiguration (AlterTSConfigurationStmt *stmt)

text *	serialize_deflist (List *deflist)

List *	deserialize_deflist (Datum txt)

ObjectAddress	AlterForeignServerOwner (const char *name, Oid newOwnerId)

void	AlterForeignServerOwner_oid (Oid, Oid newOwnerId)

ObjectAddress	AlterForeignDataWrapperOwner (const char *name, Oid newOwnerId)

void	AlterForeignDataWrapperOwner_oid (Oid fwdId, Oid newOwnerId)

ObjectAddress	CreateForeignDataWrapper (CreateFdwStmt *stmt)

ObjectAddress	AlterForeignDataWrapper (AlterFdwStmt *stmt)

void	RemoveForeignDataWrapperById (Oid fdwId)

ObjectAddress	CreateForeignServer (CreateForeignServerStmt *stmt)

ObjectAddress	AlterForeignServer (AlterForeignServerStmt *stmt)

void	RemoveForeignServerById (Oid srvId)

ObjectAddress	CreateUserMapping (CreateUserMappingStmt *stmt)

ObjectAddress	AlterUserMapping (AlterUserMappingStmt *stmt)

Oid	RemoveUserMapping (DropUserMappingStmt *stmt)

void	RemoveUserMappingById (Oid umId)

void	CreateForeignTable (CreateForeignTableStmt *stmt, Oid relid)

void	ImportForeignSchema (ImportForeignSchemaStmt *stmt)

Datum	transformGenericOptions (Oid catalogId, Datum oldOptions, List *options, Oid fdwvalidator)

ObjectAddress	CreateAccessMethod (CreateAmStmt *stmt)

void	RemoveAccessMethodById (Oid amOid)

Oid	get_index_am_oid (const char *amname, bool missing_ok)

Oid	get_am_oid (const char *amname, bool missing_ok)

char *	get_am_name (Oid amOid)

char *	defGetString (DefElem *def)

double	defGetNumeric (DefElem *def)

bool	defGetBoolean (DefElem *def)

int32	defGetInt32 (DefElem *def)

int64	defGetInt64 (DefElem *def)

List *	defGetQualifiedName (DefElem *def)

TypeName *	defGetTypeName (DefElem *def)

int	defGetTypeLength (DefElem *def)

List *	defGetStringList (DefElem *def)

Function Documentation

ObjectAddress AlterForeignDataWrapper ( AlterFdwStmt * stmt )

Definition at line 673 of file foreigncmds.c.

References Anum_pg_foreign_data_wrapper_fdwhandler, Anum_pg_foreign_data_wrapper_fdwoptions, Anum_pg_foreign_data_wrapper_fdwvalidator, CatalogTupleUpdate(), ObjectAddress::classId, CStringGetDatum, DatumGetPointer, deleteDependencyRecordsForClass(), DEPENDENCY_NORMAL, ereport, errcode(), errhint(), errmsg(), ERROR, AlterFdwStmt::fdwname, FOREIGNDATAWRAPPERNAME, FOREIGNDATAWRAPPEROID, ForeignDataWrapperRelationId, AlterFdwStmt::func_options, GETSTRUCT, heap_close, heap_freetuple(), heap_modify_tuple(), heap_open(), HeapTupleGetOid, HeapTupleIsValid, InvokeObjectPostAlterHook, Natts_pg_foreign_data_wrapper, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, AlterFdwStmt::options, parse_func_options(), PointerGetDatum, PointerIsValid, ProcedureRelationId, recordDependencyOn(), RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, superuser(), SysCacheGetAttr(), HeapTupleData::t_self, transformGenericOptions(), and WARNING.

Referenced by ProcessUtilitySlow().

 {
     Relation    rel;
     HeapTuple   tp;
     Form_pg_foreign_data_wrapper fdwForm;
     Datum       repl_val[Natts_pg_foreign_data_wrapper];
     bool        repl_null[Natts_pg_foreign_data_wrapper];
     bool        repl_repl[Natts_pg_foreign_data_wrapper];
     Oid         fdwId;
     bool        isnull;
     Datum       datum;
     bool        handler_given;
     bool        validator_given;
     Oid         fdwhandler;
     Oid         fdwvalidator;
     ObjectAddress myself;
 
     rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
 
     /* Must be super user */
     if (!superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("permission denied to alter foreign-data wrapper \"%s\"",
                         stmt->fdwname),
                  errhint("Must be superuser to alter a foreign-data wrapper.")));
 
     tp = SearchSysCacheCopy1(FOREIGNDATAWRAPPERNAME,
                              CStringGetDatum(stmt->fdwname));
 
     if (!HeapTupleIsValid(tp))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("foreign-data wrapper \"%s\" does not exist", stmt->fdwname)));
 
     fdwForm = (Form_pg_foreign_data_wrapper) GETSTRUCT(tp);
     fdwId = HeapTupleGetOid(tp);
 
     memset(repl_val, 0, sizeof(repl_val));
     memset(repl_null, false, sizeof(repl_null));
     memset(repl_repl, false, sizeof(repl_repl));
 
     parse_func_options(stmt->func_options,
                        &handler_given, &fdwhandler,
                        &validator_given, &fdwvalidator);
 
     if (handler_given)
     {
         repl_val[Anum_pg_foreign_data_wrapper_fdwhandler - 1] = ObjectIdGetDatum(fdwhandler);
         repl_repl[Anum_pg_foreign_data_wrapper_fdwhandler - 1] = true;
 
         /*
          * It could be that the behavior of accessing foreign table changes
          * with the new handler.  Warn about this.
          */
         ereport(WARNING,
                 (errmsg("changing the foreign-data wrapper handler can change behavior of existing foreign tables")));
     }
 
     if (validator_given)
     {
         repl_val[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = ObjectIdGetDatum(fdwvalidator);
         repl_repl[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = true;
 
         /*
          * It could be that existing options for the FDW or dependent SERVER,
          * USER MAPPING or FOREIGN TABLE objects are no longer valid according
          * to the new validator.  Warn about this.
          */
         if (OidIsValid(fdwvalidator))
             ereport(WARNING,
                     (errmsg("changing the foreign-data wrapper validator can cause "
                             "the options for dependent objects to become invalid")));
     }
     else
     {
         /*
          * Validator is not changed, but we need it for validating options.
          */
         fdwvalidator = fdwForm->fdwvalidator;
     }
 
     /*
      * If options specified, validate and update.
      */
     if (stmt->options)
     {
         /* Extract the current options */
         datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,
                                 tp,
                                 Anum_pg_foreign_data_wrapper_fdwoptions,
                                 &isnull);
         if (isnull)
             datum = PointerGetDatum(NULL);
 
         /* Transform the options */
         datum = transformGenericOptions(ForeignDataWrapperRelationId,
                                         datum,
                                         stmt->options,
                                         fdwvalidator);
 
         if (PointerIsValid(DatumGetPointer(datum)))
             repl_val[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = datum;
         else
             repl_null[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;
 
         repl_repl[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;
     }
 
     /* Everything looks good - update the tuple */
     tp = heap_modify_tuple(tp, RelationGetDescr(rel),
                            repl_val, repl_null, repl_repl);
 
     CatalogTupleUpdate(rel, &tp->t_self, tp);
 
     heap_freetuple(tp);
 
     ObjectAddressSet(myself, ForeignDataWrapperRelationId, fdwId);
 
     /* Update function dependencies if we changed them */
     if (handler_given || validator_given)
     {
         ObjectAddress referenced;
 
         /*
          * Flush all existing dependency records of this FDW on functions; we
          * assume there can be none other than the ones we are fixing.
          */
         deleteDependencyRecordsForClass(ForeignDataWrapperRelationId,
                                         fdwId,
                                         ProcedureRelationId,
                                         DEPENDENCY_NORMAL);
 
         /* And build new ones. */
 
         if (OidIsValid(fdwhandler))
         {
             referenced.classId = ProcedureRelationId;
             referenced.objectId = fdwhandler;
             referenced.objectSubId = 0;
             recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
         }
 
         if (OidIsValid(fdwvalidator))
         {
             referenced.classId = ProcedureRelationId;
             referenced.objectId = fdwvalidator;
             referenced.objectSubId = 0;
             recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
         }
     }
 
     InvokeObjectPostAlterHook(ForeignDataWrapperRelationId, fdwId, 0);
 
     heap_close(rel, RowExclusiveLock);
 
     return myself;
 }

ObjectAddress AlterForeignDataWrapperOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 277 of file foreigncmds.c.

References AlterForeignDataWrapperOwner_internal(), CStringGetDatum, ereport, errcode(), errmsg(), ERROR, FOREIGNDATAWRAPPERNAME, ForeignDataWrapperRelationId, heap_close, heap_freetuple(), heap_open(), HeapTupleGetOid, HeapTupleIsValid, ObjectAddressSet, RowExclusiveLock, and SearchSysCacheCopy1.

Referenced by ExecAlterOwnerStmt().

 {
     Oid         fdwId;
     HeapTuple   tup;
     Relation    rel;
     ObjectAddress address;
 
     rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
 
     tup = SearchSysCacheCopy1(FOREIGNDATAWRAPPERNAME, CStringGetDatum(name));
 
     if (!HeapTupleIsValid(tup))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("foreign-data wrapper \"%s\" does not exist", name)));
 
     fdwId = HeapTupleGetOid(tup);
 
     AlterForeignDataWrapperOwner_internal(rel, tup, newOwnerId);
 
     ObjectAddressSet(address, ForeignDataWrapperRelationId, fdwId);
 
     heap_freetuple(tup);
 
     heap_close(rel, RowExclusiveLock);
 
     return address;
 }

void AlterForeignDataWrapperOwner_oid	(	Oid	fwdId,
		Oid	newOwnerId
	)

Definition at line 312 of file foreigncmds.c.

References AlterForeignDataWrapperOwner_internal(), ereport, errcode(), errmsg(), ERROR, FOREIGNDATAWRAPPEROID, ForeignDataWrapperRelationId, heap_close, heap_freetuple(), heap_open(), HeapTupleIsValid, ObjectIdGetDatum, RowExclusiveLock, and SearchSysCacheCopy1.

Referenced by shdepReassignOwned().

 {
     HeapTuple   tup;
     Relation    rel;
 
     rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
 
     tup = SearchSysCacheCopy1(FOREIGNDATAWRAPPEROID, ObjectIdGetDatum(fwdId));
 
     if (!HeapTupleIsValid(tup))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("foreign-data wrapper with OID %u does not exist", fwdId)));
 
     AlterForeignDataWrapperOwner_internal(rel, tup, newOwnerId);
 
     heap_freetuple(tup);
 
     heap_close(rel, RowExclusiveLock);
 }

ObjectAddress AlterForeignServer ( AlterForeignServerStmt * stmt )

Definition at line 985 of file foreigncmds.c.

References ACL_KIND_FOREIGN_SERVER, aclcheck_error(), ACLCHECK_NOT_OWNER, Anum_pg_foreign_server_srvoptions, Anum_pg_foreign_server_srvversion, CatalogTupleUpdate(), CStringGetDatum, CStringGetTextDatum, DatumGetPointer, ereport, errcode(), errmsg(), ERROR, ForeignDataWrapper::fdwvalidator, FOREIGNSERVERNAME, FOREIGNSERVEROID, ForeignServerRelationId, GetForeignDataWrapper(), GETSTRUCT, GetUserId(), AlterForeignServerStmt::has_version, heap_close, heap_freetuple(), heap_modify_tuple(), heap_open(), HeapTupleGetOid, HeapTupleIsValid, InvokeObjectPostAlterHook, Natts_pg_foreign_server, ObjectAddressSet, AlterForeignServerStmt::options, pg_foreign_server_ownercheck(), PointerGetDatum, PointerIsValid, RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, AlterForeignServerStmt::servername, SysCacheGetAttr(), HeapTupleData::t_self, transformGenericOptions(), and AlterForeignServerStmt::version.

Referenced by ProcessUtilitySlow().

 {
     Relation    rel;
     HeapTuple   tp;
     Datum       repl_val[Natts_pg_foreign_server];
     bool        repl_null[Natts_pg_foreign_server];
     bool        repl_repl[Natts_pg_foreign_server];
     Oid         srvId;
     Form_pg_foreign_server srvForm;
     ObjectAddress address;
 
     rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
 
     tp = SearchSysCacheCopy1(FOREIGNSERVERNAME,
                              CStringGetDatum(stmt->servername));
 
     if (!HeapTupleIsValid(tp))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("server \"%s\" does not exist", stmt->servername)));
 
     srvId = HeapTupleGetOid(tp);
     srvForm = (Form_pg_foreign_server) GETSTRUCT(tp);
 
     /*
      * Only owner or a superuser can ALTER a SERVER.
      */
     if (!pg_foreign_server_ownercheck(srvId, GetUserId()))
         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
                        stmt->servername);
 
     memset(repl_val, 0, sizeof(repl_val));
     memset(repl_null, false, sizeof(repl_null));
     memset(repl_repl, false, sizeof(repl_repl));
 
     if (stmt->has_version)
     {
         /*
          * Change the server VERSION string.
          */
         if (stmt->version)
             repl_val[Anum_pg_foreign_server_srvversion - 1] =
                 CStringGetTextDatum(stmt->version);
         else
             repl_null[Anum_pg_foreign_server_srvversion - 1] = true;
 
         repl_repl[Anum_pg_foreign_server_srvversion - 1] = true;
     }
 
     if (stmt->options)
     {
         ForeignDataWrapper *fdw = GetForeignDataWrapper(srvForm->srvfdw);
         Datum       datum;
         bool        isnull;
 
         /* Extract the current srvoptions */
         datum = SysCacheGetAttr(FOREIGNSERVEROID,
                                 tp,
                                 Anum_pg_foreign_server_srvoptions,
                                 &isnull);
         if (isnull)
             datum = PointerGetDatum(NULL);
 
         /* Prepare the options array */
         datum = transformGenericOptions(ForeignServerRelationId,
                                         datum,
                                         stmt->options,
                                         fdw->fdwvalidator);
 
         if (PointerIsValid(DatumGetPointer(datum)))
             repl_val[Anum_pg_foreign_server_srvoptions - 1] = datum;
         else
             repl_null[Anum_pg_foreign_server_srvoptions - 1] = true;
 
         repl_repl[Anum_pg_foreign_server_srvoptions - 1] = true;
     }
 
     /* Everything looks good - update the tuple */
     tp = heap_modify_tuple(tp, RelationGetDescr(rel),
                            repl_val, repl_null, repl_repl);
 
     CatalogTupleUpdate(rel, &tp->t_self, tp);
 
     InvokeObjectPostAlterHook(ForeignServerRelationId, srvId, 0);
 
     ObjectAddressSet(address, ForeignServerRelationId, srvId);
 
     heap_freetuple(tp);
 
     heap_close(rel, RowExclusiveLock);
 
     return address;
 }

ObjectAddress AlterForeignServerOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 414 of file foreigncmds.c.

References AlterForeignServerOwner_internal(), CStringGetDatum, ereport, errcode(), errmsg(), ERROR, FOREIGNSERVERNAME, ForeignServerRelationId, heap_close, heap_freetuple(), heap_open(), HeapTupleGetOid, HeapTupleIsValid, ObjectAddressSet, RowExclusiveLock, and SearchSysCacheCopy1.

Referenced by ExecAlterOwnerStmt().

 {
     Oid         servOid;
     HeapTuple   tup;
     Relation    rel;
     ObjectAddress address;
 
     rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
 
     tup = SearchSysCacheCopy1(FOREIGNSERVERNAME, CStringGetDatum(name));
 
     if (!HeapTupleIsValid(tup))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("server \"%s\" does not exist", name)));
 
     servOid = HeapTupleGetOid(tup);
 
     AlterForeignServerOwner_internal(rel, tup, newOwnerId);
 
     ObjectAddressSet(address, ForeignServerRelationId, servOid);
 
     heap_freetuple(tup);
 
     heap_close(rel, RowExclusiveLock);
 
     return address;
 }

void AlterForeignServerOwner_oid	(	Oid	,
		Oid	newOwnerId
	)

Definition at line 447 of file foreigncmds.c.

References AlterForeignServerOwner_internal(), ereport, errcode(), errmsg(), ERROR, FOREIGNSERVEROID, ForeignServerRelationId, heap_close, heap_freetuple(), heap_open(), HeapTupleIsValid, ObjectIdGetDatum, RowExclusiveLock, and SearchSysCacheCopy1.

Referenced by shdepReassignOwned().

 {
     HeapTuple   tup;
     Relation    rel;
 
     rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
 
     tup = SearchSysCacheCopy1(FOREIGNSERVEROID, ObjectIdGetDatum(srvId));
 
     if (!HeapTupleIsValid(tup))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("foreign server with OID %u does not exist", srvId)));
 
     AlterForeignServerOwner_internal(rel, tup, newOwnerId);
 
     heap_freetuple(tup);
 
     heap_close(rel, RowExclusiveLock);
 }

ObjectAddress AlterFunction	(	ParseState *	pstate,
		AlterFunctionStmt *	stmt
	)

Definition at line 1166 of file functioncmds.c.

References ACL_KIND_PROC, aclcheck_error(), ACLCHECK_NOT_OWNER, AlterFunctionStmt::actions, Anum_pg_proc_proconfig, DefElem::arg, CatalogTupleUpdate(), compute_common_attribute(), DatumGetArrayTypeP, defGetNumeric(), DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, AlterFunctionStmt::func, GETSTRUCT, GetUserId(), heap_close, heap_freetuple(), heap_modify_tuple(), heap_open(), HeapTupleIsValid, interpret_func_parallel(), interpret_func_volatility(), intVal, InvokeObjectPostAlterHook, lfirst, LookupFuncWithArgs(), NameListToString(), Natts_pg_proc, NIL, NoLock, ObjectAddressSet, ObjectIdGetDatum, ObjectWithArgs::objname, pg_proc_ownercheck(), PointerGetDatum, ProcedureRelationId, PROCOID, RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, superuser(), SysCacheGetAttr(), HeapTupleData::t_self, and update_proconfig_value().

Referenced by ProcessUtilitySlow().

 {
     HeapTuple   tup;
     Oid         funcOid;
     Form_pg_proc procForm;
     Relation    rel;
     ListCell   *l;
     DefElem    *volatility_item = NULL;
     DefElem    *strict_item = NULL;
     DefElem    *security_def_item = NULL;
     DefElem    *leakproof_item = NULL;
     List       *set_items = NIL;
     DefElem    *cost_item = NULL;
     DefElem    *rows_item = NULL;
     DefElem    *parallel_item = NULL;
     ObjectAddress address;
 
     rel = heap_open(ProcedureRelationId, RowExclusiveLock);
 
     funcOid = LookupFuncWithArgs(stmt->func, false);
 
     tup = SearchSysCacheCopy1(PROCOID, ObjectIdGetDatum(funcOid));
     if (!HeapTupleIsValid(tup)) /* should not happen */
         elog(ERROR, "cache lookup failed for function %u", funcOid);
 
     procForm = (Form_pg_proc) GETSTRUCT(tup);
 
     /* Permission check: must own function */
     if (!pg_proc_ownercheck(funcOid, GetUserId()))
         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_PROC,
                        NameListToString(stmt->func->objname));
 
     if (procForm->proisagg)
         ereport(ERROR,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("\"%s\" is an aggregate function",
                         NameListToString(stmt->func->objname))));
 
     /* Examine requested actions. */
     foreach(l, stmt->actions)
     {
         DefElem    *defel = (DefElem *) lfirst(l);
 
         if (compute_common_attribute(pstate,
                                      defel,
                                      &volatility_item,
                                      &strict_item,
                                      &security_def_item,
                                      &leakproof_item,
                                      &set_items,
                                      &cost_item,
                                      &rows_item,
                                      &parallel_item) == false)
             elog(ERROR, "option \"%s\" not recognized", defel->defname);
     }
 
     if (volatility_item)
         procForm->provolatile = interpret_func_volatility(volatility_item);
     if (strict_item)
         procForm->proisstrict = intVal(strict_item->arg);
     if (security_def_item)
         procForm->prosecdef = intVal(security_def_item->arg);
     if (leakproof_item)
     {
         procForm->proleakproof = intVal(leakproof_item->arg);
         if (procForm->proleakproof && !superuser())
             ereport(ERROR,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("only superuser can define a leakproof function")));
     }
     if (cost_item)
     {
         procForm->procost = defGetNumeric(cost_item);
         if (procForm->procost <= 0)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                      errmsg("COST must be positive")));
     }
     if (rows_item)
     {
         procForm->prorows = defGetNumeric(rows_item);
         if (procForm->prorows <= 0)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                      errmsg("ROWS must be positive")));
         if (!procForm->proretset)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                      errmsg("ROWS is not applicable when function does not return a set")));
     }
     if (set_items)
     {
         Datum       datum;
         bool        isnull;
         ArrayType  *a;
         Datum       repl_val[Natts_pg_proc];
         bool        repl_null[Natts_pg_proc];
         bool        repl_repl[Natts_pg_proc];
 
         /* extract existing proconfig setting */
         datum = SysCacheGetAttr(PROCOID, tup, Anum_pg_proc_proconfig, &isnull);
         a = isnull ? NULL : DatumGetArrayTypeP(datum);
 
         /* update according to each SET or RESET item, left to right */
         a = update_proconfig_value(a, set_items);
 
         /* update the tuple */
         memset(repl_repl, false, sizeof(repl_repl));
         repl_repl[Anum_pg_proc_proconfig - 1] = true;
 
         if (a == NULL)
         {
             repl_val[Anum_pg_proc_proconfig - 1] = (Datum) 0;
             repl_null[Anum_pg_proc_proconfig - 1] = true;
         }
         else
         {
             repl_val[Anum_pg_proc_proconfig - 1] = PointerGetDatum(a);
             repl_null[Anum_pg_proc_proconfig - 1] = false;
         }
 
         tup = heap_modify_tuple(tup, RelationGetDescr(rel),
                                 repl_val, repl_null, repl_repl);
     }
     if (parallel_item)
         procForm->proparallel = interpret_func_parallel(parallel_item);
 
     /* Do the update */
     CatalogTupleUpdate(rel, &tup->t_self, tup);
 
     InvokeObjectPostAlterHook(ProcedureRelationId, funcOid, 0);
 
     ObjectAddressSet(address, ProcedureRelationId, funcOid);
 
     heap_close(rel, NoLock);
     heap_freetuple(tup);
 
     return address;
 }

ObjectAddress AlterOperator ( AlterOperatorStmt * stmt )

Definition at line 385 of file operatorcmds.c.

References ACL_KIND_OPER, aclcheck_error(), ACLCHECK_NOT_OWNER, Anum_pg_operator_oprjoin, Anum_pg_operator_oprrest, DefElem::arg, BOOLOID, CatalogTupleUpdate(), defGetQualifiedName(), DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, GetUserId(), heap_close, heap_modify_tuple(), heap_open(), i, InvalidOid, InvokeObjectPostAlterHook, lfirst, LookupOperWithArgs(), makeOperatorDependencies(), NameStr, Natts_pg_operator, NIL, NoLock, ObjectIdGetDatum, OidIsValid, OperatorRelationId, AlterOperatorStmt::opername, OPEROID, AlterOperatorStmt::options, pg_oper_ownercheck(), pg_strcasecmp(), RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, ValidateJoinEstimator(), ValidateRestrictionEstimator(), and values.

Referenced by ProcessUtilitySlow().

 {
     ObjectAddress address;
     Oid         oprId;
     Relation    catalog;
     HeapTuple   tup;
     Form_pg_operator oprForm;
     int         i;
     ListCell   *pl;
     Datum       values[Natts_pg_operator];
     bool        nulls[Natts_pg_operator];
     bool        replaces[Natts_pg_operator];
     List       *restrictionName = NIL;  /* optional restrict. sel. procedure */
     bool        updateRestriction = false;
     Oid         restrictionOid;
     List       *joinName = NIL; /* optional join sel. procedure */
     bool        updateJoin = false;
     Oid         joinOid;
 
     /* Look up the operator */
     oprId = LookupOperWithArgs(stmt->opername, false);
     catalog = heap_open(OperatorRelationId, RowExclusiveLock);
     tup = SearchSysCacheCopy1(OPEROID, ObjectIdGetDatum(oprId));
     if (tup == NULL)
         elog(ERROR, "cache lookup failed for operator %u", oprId);
     oprForm = (Form_pg_operator) GETSTRUCT(tup);
 
     /* Process options */
     foreach(pl, stmt->options)
     {
         DefElem    *defel = (DefElem *) lfirst(pl);
         List       *param;
 
         if (defel->arg == NULL)
             param = NIL;        /* NONE, removes the function */
         else
             param = defGetQualifiedName(defel);
 
         if (pg_strcasecmp(defel->defname, "restrict") == 0)
         {
             restrictionName = param;
             updateRestriction = true;
         }
         else if (pg_strcasecmp(defel->defname, "join") == 0)
         {
             joinName = param;
             updateJoin = true;
         }
 
         /*
          * The rest of the options that CREATE accepts cannot be changed.
          * Check for them so that we can give a meaningful error message.
          */
         else if (pg_strcasecmp(defel->defname, "leftarg") == 0 ||
                  pg_strcasecmp(defel->defname, "rightarg") == 0 ||
                  pg_strcasecmp(defel->defname, "procedure") == 0 ||
                  pg_strcasecmp(defel->defname, "commutator") == 0 ||
                  pg_strcasecmp(defel->defname, "negator") == 0 ||
                  pg_strcasecmp(defel->defname, "hashes") == 0 ||
                  pg_strcasecmp(defel->defname, "merges") == 0)
         {
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("operator attribute \"%s\" cannot be changed",
                             defel->defname)));
         }
         else
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("operator attribute \"%s\" not recognized",
                             defel->defname)));
     }
 
     /* Check permissions. Must be owner. */
     if (!pg_oper_ownercheck(oprId, GetUserId()))
         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_OPER,
                        NameStr(oprForm->oprname));
 
     /*
      * Look up restriction and join estimators if specified
      */
     if (restrictionName)
         restrictionOid = ValidateRestrictionEstimator(restrictionName);
     else
         restrictionOid = InvalidOid;
     if (joinName)
         joinOid = ValidateJoinEstimator(joinName);
     else
         joinOid = InvalidOid;
 
     /* Perform additional checks, like OperatorCreate does */
     if (!(OidIsValid(oprForm->oprleft) && OidIsValid(oprForm->oprright)))
     {
         /* If it's not a binary op, these things mustn't be set: */
         if (OidIsValid(joinOid))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("only binary operators can have join selectivity")));
     }
 
     if (oprForm->oprresult != BOOLOID)
     {
         if (OidIsValid(restrictionOid))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("only boolean operators can have restriction selectivity")));
         if (OidIsValid(joinOid))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("only boolean operators can have join selectivity")));
     }
 
     /* Update the tuple */
     for (i = 0; i < Natts_pg_operator; ++i)
     {
         values[i] = (Datum) 0;
         replaces[i] = false;
         nulls[i] = false;
     }
     if (updateRestriction)
     {
         replaces[Anum_pg_operator_oprrest - 1] = true;
         values[Anum_pg_operator_oprrest - 1] = restrictionOid;
     }
     if (updateJoin)
     {
         replaces[Anum_pg_operator_oprjoin - 1] = true;
         values[Anum_pg_operator_oprjoin - 1] = joinOid;
     }
 
     tup = heap_modify_tuple(tup, RelationGetDescr(catalog),
                             values, nulls, replaces);
 
     CatalogTupleUpdate(catalog, &tup->t_self, tup);
 
     address = makeOperatorDependencies(tup, true);
 
     InvokeObjectPostAlterHook(OperatorRelationId, oprId, 0);
 
     heap_close(catalog, NoLock);
 
     return address;
 }

Oid AlterOpFamily ( AlterOpFamilyStmt * stmt )

Definition at line 764 of file opclasscmds.c.

References AlterOpFamilyAdd(), AlterOpFamilyDrop(), AMNAME, AlterOpFamilyStmt::amname, IndexAmRoutine::amstrategies, IndexAmRoutine::amsupport, CStringGetDatum, ereport, errcode(), errmsg(), ERROR, get_opfamily_oid(), GetIndexAmRoutineByAmId(), HeapTupleGetOid, HeapTupleIsValid, AlterOpFamilyStmt::isDrop, AlterOpFamilyStmt::items, AlterOpFamilyStmt::opfamilyname, ReleaseSysCache(), SearchSysCache1, and superuser().

Referenced by ProcessUtilitySlow().

 {
     Oid         amoid,          /* our AM's oid */
                 opfamilyoid;    /* oid of opfamily */
     int         maxOpNumber,    /* amstrategies value */
                 maxProcNumber;  /* amsupport value */
     HeapTuple   tup;
     IndexAmRoutine *amroutine;
 
     /* Get necessary info about access method */
     tup = SearchSysCache1(AMNAME, CStringGetDatum(stmt->amname));
     if (!HeapTupleIsValid(tup))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("access method \"%s\" does not exist",
                         stmt->amname)));
 
     amoid = HeapTupleGetOid(tup);
     amroutine = GetIndexAmRoutineByAmId(amoid, false);
     ReleaseSysCache(tup);
 
     maxOpNumber = amroutine->amstrategies;
     /* if amstrategies is zero, just enforce that op numbers fit in int16 */
     if (maxOpNumber <= 0)
         maxOpNumber = SHRT_MAX;
     maxProcNumber = amroutine->amsupport;
 
     /* XXX Should we make any privilege check against the AM? */
 
     /* Look up the opfamily */
     opfamilyoid = get_opfamily_oid(amoid, stmt->opfamilyname, false);
 
     /*
      * Currently, we require superuser privileges to alter an opfamily.
      *
      * XXX re-enable NOT_USED code sections below if you remove this test.
      */
     if (!superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be superuser to alter an operator family")));
 
     /*
      * ADD and DROP cases need separate code from here on down.
      */
     if (stmt->isDrop)
         AlterOpFamilyDrop(stmt, amoid, opfamilyoid,
                           maxOpNumber, maxProcNumber, stmt->items);
     else
         AlterOpFamilyAdd(stmt, amoid, opfamilyoid,
                          maxOpNumber, maxProcNumber, stmt->items);
 
     return opfamilyoid;
 }

ObjectAddress AlterTSConfiguration ( AlterTSConfigurationStmt * stmt )

Definition at line 1173 of file tsearchcmds.c.

References ACL_KIND_TSCONFIGURATION, aclcheck_error(), ACLCHECK_NOT_OWNER, AlterTSConfigurationStmt::cfgname, AlterTSConfigurationStmt::dicts, DropConfigurationMapping(), ereport, errcode(), errmsg(), ERROR, GetTSConfigTuple(), GetUserId(), heap_close, heap_open(), HeapTupleGetOid, HeapTupleIsValid, InvokeObjectPostAlterHook, makeConfigurationDependencies(), MakeConfigurationMapping(), NameListToString(), ObjectAddressSet, pg_ts_config_ownercheck(), ReleaseSysCache(), RowExclusiveLock, AlterTSConfigurationStmt::tokentype, TSConfigMapRelationId, and TSConfigRelationId.

Referenced by ProcessUtilitySlow().

 {
     HeapTuple   tup;
     Oid         cfgId;
     Relation    relMap;
     ObjectAddress address;
 
     /* Find the configuration */
     tup = GetTSConfigTuple(stmt->cfgname);
     if (!HeapTupleIsValid(tup))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("text search configuration \"%s\" does not exist",
                         NameListToString(stmt->cfgname))));
 
     cfgId = HeapTupleGetOid(tup);
 
     /* must be owner */
     if (!pg_ts_config_ownercheck(HeapTupleGetOid(tup), GetUserId()))
         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSCONFIGURATION,
                        NameListToString(stmt->cfgname));
 
     relMap = heap_open(TSConfigMapRelationId, RowExclusiveLock);
 
     /* Add or drop mappings */
     if (stmt->dicts)
         MakeConfigurationMapping(stmt, tup, relMap);
     else if (stmt->tokentype)
         DropConfigurationMapping(stmt, tup, relMap);
 
     /* Update dependencies */
     makeConfigurationDependencies(tup, true, relMap);
 
     InvokeObjectPostAlterHook(TSConfigRelationId,
                               HeapTupleGetOid(tup), 0);
 
     ObjectAddressSet(address, TSConfigRelationId, cfgId);
 
     heap_close(relMap, RowExclusiveLock);
 
     ReleaseSysCache(tup);
 
     return address;
 }

ObjectAddress AlterTSDictionary ( AlterTSDictionaryStmt * stmt )

Definition at line 525 of file tsearchcmds.c.

References ACL_KIND_TSDICTIONARY, aclcheck_error(), ACLCHECK_NOT_OWNER, Anum_pg_ts_dict_dictinitoption, DefElem::arg, CatalogTupleUpdate(), DefElem::defname, deserialize_deflist(), AlterTSDictionaryStmt::dictname, elog, ERROR, get_ts_dict_oid(), GETSTRUCT, GetUserId(), heap_close, heap_freetuple(), heap_modify_tuple(), heap_open(), HeapTupleIsValid, InvokeObjectPostAlterHook, lappend(), lfirst, list_delete_cell(), list_head(), lnext, NameListToString(), Natts_pg_ts_dict, next, NIL, ObjectAddressSet, ObjectIdGetDatum, AlterTSDictionaryStmt::options, pg_strcasecmp(), pg_ts_dict_ownercheck(), PointerGetDatum, RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1, serialize_deflist(), SysCacheGetAttr(), HeapTupleData::t_self, TSDictionaryRelationId, TSDICTOID, and verify_dictoptions().

Referenced by ProcessUtilitySlow().

 {
     HeapTuple   tup,
                 newtup;
     Relation    rel;
     Oid         dictId;
     ListCell   *pl;
     List       *dictoptions;
     Datum       opt;
     bool        isnull;
     Datum       repl_val[Natts_pg_ts_dict];
     bool        repl_null[Natts_pg_ts_dict];
     bool        repl_repl[Natts_pg_ts_dict];
     ObjectAddress address;
 
     dictId = get_ts_dict_oid(stmt->dictname, false);
 
     rel = heap_open(TSDictionaryRelationId, RowExclusiveLock);
 
     tup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictId));
 
     if (!HeapTupleIsValid(tup))
         elog(ERROR, "cache lookup failed for text search dictionary %u",
              dictId);
 
     /* must be owner */
     if (!pg_ts_dict_ownercheck(dictId, GetUserId()))
         aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSDICTIONARY,
                        NameListToString(stmt->dictname));
 
     /* deserialize the existing set of options */
     opt = SysCacheGetAttr(TSDICTOID, tup,
                           Anum_pg_ts_dict_dictinitoption,
                           &isnull);
     if (isnull)
         dictoptions = NIL;
     else
         dictoptions = deserialize_deflist(opt);
 
     /*
      * Modify the options list as per specified changes
      */
     foreach(pl, stmt->options)
     {
         DefElem    *defel = (DefElem *) lfirst(pl);
         ListCell   *cell;
         ListCell   *prev;
         ListCell   *next;
 
         /*
          * Remove any matches ...
          */
         prev = NULL;
         for (cell = list_head(dictoptions); cell; cell = next)
         {
             DefElem    *oldel = (DefElem *) lfirst(cell);
 
             next = lnext(cell);
             if (pg_strcasecmp(oldel->defname, defel->defname) == 0)
                 dictoptions = list_delete_cell(dictoptions, cell, prev);
             else
                 prev = cell;
         }
 
         /*
          * and add new value if it's got one
          */
         if (defel->arg)
             dictoptions = lappend(dictoptions, defel);
     }
 
     /*
      * Validate
      */
     verify_dictoptions(((Form_pg_ts_dict) GETSTRUCT(tup))->dicttemplate,
                        dictoptions);
 
     /*
      * Looks good, update
      */
     memset(repl_val, 0, sizeof(repl_val));
     memset(repl_null, false, sizeof(repl_null));
     memset(repl_repl, false, sizeof(repl_repl));
 
     if (dictoptions)
         repl_val[Anum_pg_ts_dict_dictinitoption - 1] =
             PointerGetDatum(serialize_deflist(dictoptions));
     else
         repl_null[Anum_pg_ts_dict_dictinitoption - 1] = true;
     repl_repl[Anum_pg_ts_dict_dictinitoption - 1] = true;
 
     newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
                                repl_val, repl_null, repl_repl);
 
     CatalogTupleUpdate(rel, &newtup->t_self, newtup);
 
     InvokeObjectPostAlterHook(TSDictionaryRelationId, dictId, 0);
 
     ObjectAddressSet(address, TSDictionaryRelationId, dictId);
 
     /*
      * NOTE: because we only support altering the options, not the template,
      * there is no need to update dependencies.  This might have to change if
      * the options ever reference inside-the-database objects.
      */
 
     heap_freetuple(newtup);
     ReleaseSysCache(tup);
 
     heap_close(rel, RowExclusiveLock);
 
     return address;
 }

ObjectAddress AlterUserMapping ( AlterUserMappingStmt * stmt )

Definition at line 1250 of file foreigncmds.c.

References ACL_ID_PUBLIC, Anum_pg_user_mapping_umoptions, CatalogTupleUpdate(), DatumGetPointer, elog, ereport, errcode(), errmsg(), ERROR, ForeignServer::fdwid, ForeignDataWrapper::fdwvalidator, get_rolespec_oid(), GetForeignDataWrapper(), GetForeignServerByName(), GetSysCacheOid2, heap_close, heap_freetuple(), heap_modify_tuple(), heap_open(), HeapTupleIsValid, MappingUserName, Natts_pg_user_mapping, ObjectAddressSet, ObjectIdGetDatum, OidIsValid, AlterUserMappingStmt::options, PointerGetDatum, PointerIsValid, RelationGetDescr, ROLESPEC_PUBLIC, RoleSpec::roletype, RowExclusiveLock, SearchSysCacheCopy1, ForeignServer::serverid, AlterUserMappingStmt::servername, SysCacheGetAttr(), HeapTupleData::t_self, transformGenericOptions(), AlterUserMappingStmt::user, user_mapping_ddl_aclcheck(), USERMAPPINGOID, and UserMappingRelationId.

Referenced by ProcessUtilitySlow().

 {
     Relation    rel;
     HeapTuple   tp;
     Datum       repl_val[Natts_pg_user_mapping];
     bool        repl_null[Natts_pg_user_mapping];
     bool        repl_repl[Natts_pg_user_mapping];
     Oid         useId;
     Oid         umId;
     ForeignServer *srv;
     ObjectAddress address;
     RoleSpec   *role = (RoleSpec *) stmt->user;
 
     rel = heap_open(UserMappingRelationId, RowExclusiveLock);
 
     if (role->roletype == ROLESPEC_PUBLIC)
         useId = ACL_ID_PUBLIC;
     else
         useId = get_rolespec_oid(stmt->user, false);
 
     srv = GetForeignServerByName(stmt->servername, false);
 
     umId = GetSysCacheOid2(USERMAPPINGUSERSERVER,
                            ObjectIdGetDatum(useId),
                            ObjectIdGetDatum(srv->serverid));
     if (!OidIsValid(umId))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("user mapping for \"%s\" does not exist for the server",
                         MappingUserName(useId))));
 
     user_mapping_ddl_aclcheck(useId, srv->serverid, stmt->servername);
 
     tp = SearchSysCacheCopy1(USERMAPPINGOID, ObjectIdGetDatum(umId));
 
     if (!HeapTupleIsValid(tp))
         elog(ERROR, "cache lookup failed for user mapping %u", umId);
 
     memset(repl_val, 0, sizeof(repl_val));
     memset(repl_null, false, sizeof(repl_null));
     memset(repl_repl, false, sizeof(repl_repl));
 
     if (stmt->options)
     {
         ForeignDataWrapper *fdw;
         Datum       datum;
         bool        isnull;
 
         /*
          * Process the options.
          */
 
         fdw = GetForeignDataWrapper(srv->fdwid);
 
         datum = SysCacheGetAttr(USERMAPPINGUSERSERVER,
                                 tp,
                                 Anum_pg_user_mapping_umoptions,
                                 &isnull);
         if (isnull)
             datum = PointerGetDatum(NULL);
 
         /* Prepare the options array */
         datum = transformGenericOptions(UserMappingRelationId,
                                         datum,
                                         stmt->options,
                                         fdw->fdwvalidator);
 
         if (PointerIsValid(DatumGetPointer(datum)))
             repl_val[Anum_pg_user_mapping_umoptions - 1] = datum;
         else
             repl_null[Anum_pg_user_mapping_umoptions - 1] = true;
 
         repl_repl[Anum_pg_user_mapping_umoptions - 1] = true;
     }
 
     /* Everything looks good - update the tuple */
     tp = heap_modify_tuple(tp, RelationGetDescr(rel),
                            repl_val, repl_null, repl_repl);
 
     CatalogTupleUpdate(rel, &tp->t_self, tp);
 
     ObjectAddressSet(address, UserMappingRelationId, umId);
 
     heap_freetuple(tp);
 
     heap_close(rel, RowExclusiveLock);
 
     return address;
 }

bool CheckIndexCompatible	(	Oid	oldId,
		char *	accessMethodName,
		List *	attributeList,
		List *	exclusionOpNames
	)

Definition at line 117 of file indexcmds.c.

References AccessShareLock, IndexAmRoutine::amcanorder, AMNAME, Anum_pg_index_indclass, Anum_pg_index_indcollation, Anum_pg_index_indexprs, Anum_pg_index_indpred, Assert, ComputeIndexAttrs(), CurrentMemoryContext, DatumGetPointer, elog, ereport, errcode(), errmsg(), ERROR, get_opclass_input_type(), GetIndexAmRoutine(), GETSTRUCT, heap_attisnull(), HeapTupleGetOid, HeapTupleIsValid, i, IndexInfo::ii_AmCache, IndexInfo::ii_Context, IndexInfo::ii_ExclusionOps, IndexInfo::ii_ExclusionProcs, IndexInfo::ii_ExclusionStrats, IndexInfo::ii_Expressions, IndexInfo::ii_ExpressionsState, IndexInfo::ii_PredicateState, index_close(), INDEX_MAX_KEYS, index_open(), IndexGetRelation(), IndexIsValid, INDEXRELID, IsPolymorphicType, list_length(), makeNode, NIL, NoLock, ObjectIdGetDatum, op_input_types(), palloc(), PointerGetDatum, RelationData::rd_att, RelationGetExclusionInfo(), ReleaseSysCache(), SearchSysCache1, SysCacheGetAttr(), TupleDescAttr, and oidvector::values.

Referenced by TryReuseIndex().

 {
     bool        isconstraint;
     Oid        *typeObjectId;
     Oid        *collationObjectId;
     Oid        *classObjectId;
     Oid         accessMethodId;
     Oid         relationId;
     HeapTuple   tuple;
     Form_pg_index indexForm;
     Form_pg_am  accessMethodForm;
     IndexAmRoutine *amRoutine;
     bool        amcanorder;
     int16      *coloptions;
     IndexInfo  *indexInfo;
     int         numberOfAttributes;
     int         old_natts;
     bool        isnull;
     bool        ret = true;
     oidvector  *old_indclass;
     oidvector  *old_indcollation;
     Relation    irel;
     int         i;
     Datum       d;
 
     /* Caller should already have the relation locked in some way. */
     relationId = IndexGetRelation(oldId, false);
 
     /*
      * We can pretend isconstraint = false unconditionally.  It only serves to
      * decide the text of an error message that should never happen for us.
      */
     isconstraint = false;
 
     numberOfAttributes = list_length(attributeList);
     Assert(numberOfAttributes > 0);
     Assert(numberOfAttributes <= INDEX_MAX_KEYS);
 
     /* look up the access method */
     tuple = SearchSysCache1(AMNAME, PointerGetDatum(accessMethodName));
     if (!HeapTupleIsValid(tuple))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("access method \"%s\" does not exist",
                         accessMethodName)));
     accessMethodId = HeapTupleGetOid(tuple);
     accessMethodForm = (Form_pg_am) GETSTRUCT(tuple);
     amRoutine = GetIndexAmRoutine(accessMethodForm->amhandler);
     ReleaseSysCache(tuple);
 
     amcanorder = amRoutine->amcanorder;
 
     /*
      * Compute the operator classes, collations, and exclusion operators for
      * the new index, so we can test whether it's compatible with the existing
      * one.  Note that ComputeIndexAttrs might fail here, but that's OK:
      * DefineIndex would have called this function with the same arguments
      * later on, and it would have failed then anyway.
      */
     indexInfo = makeNode(IndexInfo);
     indexInfo->ii_Expressions = NIL;
     indexInfo->ii_ExpressionsState = NIL;
     indexInfo->ii_PredicateState = NULL;
     indexInfo->ii_ExclusionOps = NULL;
     indexInfo->ii_ExclusionProcs = NULL;
     indexInfo->ii_ExclusionStrats = NULL;
     indexInfo->ii_AmCache = NULL;
     indexInfo->ii_Context = CurrentMemoryContext;
     typeObjectId = (Oid *) palloc(numberOfAttributes * sizeof(Oid));
     collationObjectId = (Oid *) palloc(numberOfAttributes * sizeof(Oid));
     classObjectId = (Oid *) palloc(numberOfAttributes * sizeof(Oid));
     coloptions = (int16 *) palloc(numberOfAttributes * sizeof(int16));
     ComputeIndexAttrs(indexInfo,
                       typeObjectId, collationObjectId, classObjectId,
                       coloptions, attributeList,
                       exclusionOpNames, relationId,
                       accessMethodName, accessMethodId,
                       amcanorder, isconstraint);
 
 
     /* Get the soon-obsolete pg_index tuple. */
     tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(oldId));
     if (!HeapTupleIsValid(tuple))
         elog(ERROR, "cache lookup failed for index %u", oldId);
     indexForm = (Form_pg_index) GETSTRUCT(tuple);
 
     /*
      * We don't assess expressions or predicates; assume incompatibility.
      * Also, if the index is invalid for any reason, treat it as incompatible.
      */
     if (!(heap_attisnull(tuple, Anum_pg_index_indpred) &&
           heap_attisnull(tuple, Anum_pg_index_indexprs) &&
           IndexIsValid(indexForm)))
     {
         ReleaseSysCache(tuple);
         return false;
     }
 
     /* Any change in operator class or collation breaks compatibility. */
     old_natts = indexForm->indnatts;
     Assert(old_natts == numberOfAttributes);
 
     d = SysCacheGetAttr(INDEXRELID, tuple, Anum_pg_index_indcollation, &isnull);
     Assert(!isnull);
     old_indcollation = (oidvector *) DatumGetPointer(d);
 
     d = SysCacheGetAttr(INDEXRELID, tuple, Anum_pg_index_indclass, &isnull);
     Assert(!isnull);
     old_indclass = (oidvector *) DatumGetPointer(d);
 
     ret = (memcmp(old_indclass->values, classObjectId,
                   old_natts * sizeof(Oid)) == 0 &&
            memcmp(old_indcollation->values, collationObjectId,
                   old_natts * sizeof(Oid)) == 0);
 
     ReleaseSysCache(tuple);
 
     if (!ret)
         return false;
 
     /* For polymorphic opcintype, column type changes break compatibility. */
     irel = index_open(oldId, AccessShareLock);  /* caller probably has a lock */
     for (i = 0; i < old_natts; i++)
     {
         if (IsPolymorphicType(get_opclass_input_type(classObjectId[i])) &&
             TupleDescAttr(irel->rd_att, i)->atttypid != typeObjectId[i])
         {
             ret = false;
             break;
         }
     }
 
     /* Any change in exclusion operator selections breaks compatibility. */
     if (ret && indexInfo->ii_ExclusionOps != NULL)
     {
         Oid        *old_operators,
                    *old_procs;
         uint16     *old_strats;
 
         RelationGetExclusionInfo(irel, &old_operators, &old_procs, &old_strats);
         ret = memcmp(old_operators, indexInfo->ii_ExclusionOps,
                      old_natts * sizeof(Oid)) == 0;
 
         /* Require an exact input type match for polymorphic operators. */
         if (ret)
         {
             for (i = 0; i < old_natts && ret; i++)
             {
                 Oid         left,
                             right;
 
                 op_input_types(indexInfo->ii_ExclusionOps[i], &left, &right);
                 if ((IsPolymorphicType(left) || IsPolymorphicType(right)) &&
                     TupleDescAttr(irel->rd_att, i)->atttypid != typeObjectId[i])
                 {
                     ret = false;
                     break;
                 }
             }
         }
     }
 
     index_close(irel, NoLock);
     return ret;
 }

char* ChooseRelationName	(	const char *	name1,
		const char *	name2,
		const char *	label,
		Oid	namespaceid
	)

Definition at line 1579 of file indexcmds.c.

References get_relname_relid(), makeObjectName(), NAMEDATALEN, OidIsValid, pfree(), snprintf(), and StrNCpy.

Referenced by ChooseIndexName(), and generateSerialExtraStmts().

 {
     int         pass = 0;
     char       *relname = NULL;
     char        modlabel[NAMEDATALEN];
 
     /* try the unmodified label first */
     StrNCpy(modlabel, label, sizeof(modlabel));
 
     for (;;)
     {
         relname = makeObjectName(name1, name2, modlabel);
 
         if (!OidIsValid(get_relname_relid(relname, namespaceid)))
             break;
 
         /* found a conflict, so try a new name component */
         pfree(relname);
         snprintf(modlabel, sizeof(modlabel), "%s%d", label, ++pass);
     }
 
     return relname;
 }

ObjectAddress CreateAccessMethod ( CreateAmStmt * stmt )

Definition at line 41 of file amcmds.c.

References AccessMethodRelationId, AMNAME, CreateAmStmt::amname, CreateAmStmt::amtype, Anum_pg_am_amhandler, Anum_pg_am_amname, Anum_pg_am_amtype, CatalogTupleInsert(), CharGetDatum, ObjectAddress::classId, CStringGetDatum, DEPENDENCY_NORMAL, DirectFunctionCall1, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errhint(), errmsg(), ERROR, GetSysCacheOid1, CreateAmStmt::handler_name, heap_close, heap_form_tuple(), heap_freetuple(), heap_open(), lookup_index_am_handler_func(), namein(), Natts_pg_am, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, ProcedureRelationId, recordDependencyOn(), recordDependencyOnCurrentExtension(), RelationGetDescr, RowExclusiveLock, superuser(), and values.

Referenced by ProcessUtilitySlow().

 {
     Relation    rel;
     ObjectAddress myself;
     ObjectAddress referenced;
     Oid         amoid;
     Oid         amhandler;
     bool        nulls[Natts_pg_am];
     Datum       values[Natts_pg_am];
     HeapTuple   tup;
 
     rel = heap_open(AccessMethodRelationId, RowExclusiveLock);
 
     /* Must be super user */
     if (!superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("permission denied to create access method \"%s\"",
                         stmt->amname),
                  errhint("Must be superuser to create an access method.")));
 
     /* Check if name is used */
     amoid = GetSysCacheOid1(AMNAME, CStringGetDatum(stmt->amname));
     if (OidIsValid(amoid))
     {
         ereport(ERROR,
                 (errcode(ERRCODE_DUPLICATE_OBJECT),
                  errmsg("access method \"%s\" already exists",
                         stmt->amname)));
     }
 
     /*
      * Get the handler function oid, verifying the AM type while at it.
      */
     amhandler = lookup_index_am_handler_func(stmt->handler_name, stmt->amtype);
 
     /*
      * Insert tuple into pg_am.
      */
     memset(values, 0, sizeof(values));
     memset(nulls, false, sizeof(nulls));
 
     values[Anum_pg_am_amname - 1] =
         DirectFunctionCall1(namein, CStringGetDatum(stmt->amname));
     values[Anum_pg_am_amhandler - 1] = ObjectIdGetDatum(amhandler);
     values[Anum_pg_am_amtype - 1] = CharGetDatum(stmt->amtype);
 
     tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
 
     amoid = CatalogTupleInsert(rel, tup);
     heap_freetuple(tup);
 
     myself.classId = AccessMethodRelationId;
     myself.objectId = amoid;
     myself.objectSubId = 0;
 
     /* Record dependency on handler function */
     referenced.classId = ProcedureRelationId;
     referenced.objectId = amhandler;
     referenced.objectSubId = 0;
 
     recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
     recordDependencyOnCurrentExtension(&myself, false);
 
     heap_close(rel, RowExclusiveLock);
 
     return myself;
 }

ObjectAddress CreateCast ( CreateCastStmt * stmt )

Definition at line 1398 of file functioncmds.c.

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, Anum_pg_cast_castcontext, Anum_pg_cast_castfunc, Anum_pg_cast_castmethod, Anum_pg_cast_castsource, Anum_pg_cast_casttarget, BOOLOID, CastRelationId, CASTSOURCETARGET, CatalogTupleInsert(), CharGetDatum, ObjectAddress::classId, COERCION_ASSIGNMENT, COERCION_CODE_ASSIGNMENT, COERCION_CODE_EXPLICIT, COERCION_CODE_IMPLICIT, COERCION_EXPLICIT, COERCION_IMPLICIT, COERCION_METHOD_BINARY, COERCION_METHOD_FUNCTION, COERCION_METHOD_INOUT, CreateCastStmt::context, DEPENDENCY_NORMAL, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, format_type_be(), CreateCastStmt::func, get_element_type(), get_typlenbyvalalign(), get_typtype(), GETSTRUCT, GetUserId(), heap_close, heap_form_tuple(), heap_freetuple(), heap_open(), HeapTupleIsValid, CreateCastStmt::inout, INT4OID, InvalidOid, InvokeObjectPostCreateHook, IsBinaryCoercible(), LookupFuncWithArgs(), MemSet, Natts_pg_cast, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, pg_type_aclcheck(), pg_type_ownercheck(), ProcedureRelationId, PROCOID, PROVOLATILE_VOLATILE, recordDependencyOn(), recordDependencyOnCurrentExtension(), RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1, SearchSysCache2, CreateCastStmt::sourcetype, superuser(), CreateCastStmt::targettype, TypeNameToString(), typenameTypeId(), TypeRelationId, TYPTYPE_COMPOSITE, TYPTYPE_DOMAIN, TYPTYPE_ENUM, TYPTYPE_PSEUDO, values, and WARNING.

Referenced by ProcessUtilitySlow().

 {
     Oid         sourcetypeid;
     Oid         targettypeid;
     char        sourcetyptype;
     char        targettyptype;
     Oid         funcid;
     Oid         castid;
     int         nargs;
     char        castcontext;
     char        castmethod;
     Relation    relation;
     HeapTuple   tuple;
     Datum       values[Natts_pg_cast];
     bool        nulls[Natts_pg_cast];
     ObjectAddress myself,
                 referenced;
     AclResult   aclresult;
 
     sourcetypeid = typenameTypeId(NULL, stmt->sourcetype);
     targettypeid = typenameTypeId(NULL, stmt->targettype);
     sourcetyptype = get_typtype(sourcetypeid);
     targettyptype = get_typtype(targettypeid);
 
     /* No pseudo-types allowed */
     if (sourcetyptype == TYPTYPE_PSEUDO)
         ereport(ERROR,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("source data type %s is a pseudo-type",
                         TypeNameToString(stmt->sourcetype))));
 
     if (targettyptype == TYPTYPE_PSEUDO)
         ereport(ERROR,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("target data type %s is a pseudo-type",
                         TypeNameToString(stmt->targettype))));
 
     /* Permission check */
     if (!pg_type_ownercheck(sourcetypeid, GetUserId())
         && !pg_type_ownercheck(targettypeid, GetUserId()))
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("must be owner of type %s or type %s",
                         format_type_be(sourcetypeid),
                         format_type_be(targettypeid))));
 
     aclresult = pg_type_aclcheck(sourcetypeid, GetUserId(), ACL_USAGE);
     if (aclresult != ACLCHECK_OK)
         aclcheck_error_type(aclresult, sourcetypeid);
 
     aclresult = pg_type_aclcheck(targettypeid, GetUserId(), ACL_USAGE);
     if (aclresult != ACLCHECK_OK)
         aclcheck_error_type(aclresult, targettypeid);
 
     /* Domains are allowed for historical reasons, but we warn */
     if (sourcetyptype == TYPTYPE_DOMAIN)
         ereport(WARNING,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("cast will be ignored because the source data type is a domain")));
 
     else if (targettyptype == TYPTYPE_DOMAIN)
         ereport(WARNING,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("cast will be ignored because the target data type is a domain")));
 
     /* Determine the cast method */
     if (stmt->func != NULL)
         castmethod = COERCION_METHOD_FUNCTION;
     else if (stmt->inout)
         castmethod = COERCION_METHOD_INOUT;
     else
         castmethod = COERCION_METHOD_BINARY;
 
     if (castmethod == COERCION_METHOD_FUNCTION)
     {
         Form_pg_proc procstruct;
 
         funcid = LookupFuncWithArgs(stmt->func, false);
 
         tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
         if (!HeapTupleIsValid(tuple))
             elog(ERROR, "cache lookup failed for function %u", funcid);
 
         procstruct = (Form_pg_proc) GETSTRUCT(tuple);
         nargs = procstruct->pronargs;
         if (nargs < 1 || nargs > 3)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("cast function must take one to three arguments")));
         if (!IsBinaryCoercible(sourcetypeid, procstruct->proargtypes.values[0]))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("argument of cast function must match or be binary-coercible from source data type")));
         if (nargs > 1 && procstruct->proargtypes.values[1] != INT4OID)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("second argument of cast function must be type %s",
                             "integer")));
         if (nargs > 2 && procstruct->proargtypes.values[2] != BOOLOID)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("third argument of cast function must be type %s",
                             "boolean")));
         if (!IsBinaryCoercible(procstruct->prorettype, targettypeid))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("return data type of cast function must match or be binary-coercible to target data type")));
 
         /*
          * Restricting the volatility of a cast function may or may not be a
          * good idea in the abstract, but it definitely breaks many old
          * user-defined types.  Disable this check --- tgl 2/1/03
          */
 #ifdef NOT_USED
         if (procstruct->provolatile == PROVOLATILE_VOLATILE)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("cast function must not be volatile")));
 #endif
         if (procstruct->proisagg)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("cast function must not be an aggregate function")));
         if (procstruct->proiswindow)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("cast function must not be a window function")));
         if (procstruct->proretset)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("cast function must not return a set")));
 
         ReleaseSysCache(tuple);
     }
     else
     {
         funcid = InvalidOid;
         nargs = 0;
     }
 
     if (castmethod == COERCION_METHOD_BINARY)
     {
         int16       typ1len;
         int16       typ2len;
         bool        typ1byval;
         bool        typ2byval;
         char        typ1align;
         char        typ2align;
 
         /*
          * Must be superuser to create binary-compatible casts, since
          * erroneous casts can easily crash the backend.
          */
         if (!superuser())
             ereport(ERROR,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("must be superuser to create a cast WITHOUT FUNCTION")));
 
         /*
          * Also, insist that the types match as to size, alignment, and
          * pass-by-value attributes; this provides at least a crude check that
          * they have similar representations.  A pair of types that fail this
          * test should certainly not be equated.
          */
         get_typlenbyvalalign(sourcetypeid, &typ1len, &typ1byval, &typ1align);
         get_typlenbyvalalign(targettypeid, &typ2len, &typ2byval, &typ2align);
         if (typ1len != typ2len ||
             typ1byval != typ2byval ||
             typ1align != typ2align)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("source and target data types are not physically compatible")));
 
         /*
          * We know that composite, enum and array types are never binary-
          * compatible with each other.  They all have OIDs embedded in them.
          *
          * Theoretically you could build a user-defined base type that is
          * binary-compatible with a composite, enum, or array type.  But we
          * disallow that too, as in practice such a cast is surely a mistake.
          * You can always work around that by writing a cast function.
          */
         if (sourcetyptype == TYPTYPE_COMPOSITE ||
             targettyptype == TYPTYPE_COMPOSITE)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("composite data types are not binary-compatible")));
 
         if (sourcetyptype == TYPTYPE_ENUM ||
             targettyptype == TYPTYPE_ENUM)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("enum data types are not binary-compatible")));
 
         if (OidIsValid(get_element_type(sourcetypeid)) ||
             OidIsValid(get_element_type(targettypeid)))
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("array data types are not binary-compatible")));
 
         /*
          * We also disallow creating binary-compatibility casts involving
          * domains.  Casting from a domain to its base type is already
          * allowed, and casting the other way ought to go through domain
          * coercion to permit constraint checking.  Again, if you're intent on
          * having your own semantics for that, create a no-op cast function.
          *
          * NOTE: if we were to relax this, the above checks for composites
          * etc. would have to be modified to look through domains to their
          * base types.
          */
         if (sourcetyptype == TYPTYPE_DOMAIN ||
             targettyptype == TYPTYPE_DOMAIN)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("domain data types must not be marked binary-compatible")));
     }
 
     /*
      * Allow source and target types to be same only for length coercion
      * functions.  We assume a multi-arg function does length coercion.
      */
     if (sourcetypeid == targettypeid && nargs < 2)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                  errmsg("source data type and target data type are the same")));
 
     /* convert CoercionContext enum to char value for castcontext */
     switch (stmt->context)
     {
         case COERCION_IMPLICIT:
             castcontext = COERCION_CODE_IMPLICIT;
             break;
         case COERCION_ASSIGNMENT:
             castcontext = COERCION_CODE_ASSIGNMENT;
             break;
         case COERCION_EXPLICIT:
             castcontext = COERCION_CODE_EXPLICIT;
             break;
         default:
             elog(ERROR, "unrecognized CoercionContext: %d", stmt->context);
             castcontext = 0;    /* keep compiler quiet */
             break;
     }
 
     relation = heap_open(CastRelationId, RowExclusiveLock);
 
     /*
      * Check for duplicate.  This is just to give a friendly error message,
      * the unique index would catch it anyway (so no need to sweat about race
      * conditions).
      */
     tuple = SearchSysCache2(CASTSOURCETARGET,
                             ObjectIdGetDatum(sourcetypeid),
                             ObjectIdGetDatum(targettypeid));
     if (HeapTupleIsValid(tuple))
         ereport(ERROR,
                 (errcode(ERRCODE_DUPLICATE_OBJECT),
                  errmsg("cast from type %s to type %s already exists",
                         format_type_be(sourcetypeid),
                         format_type_be(targettypeid))));
 
     /* ready to go */
     values[Anum_pg_cast_castsource - 1] = ObjectIdGetDatum(sourcetypeid);
     values[Anum_pg_cast_casttarget - 1] = ObjectIdGetDatum(targettypeid);
     values[Anum_pg_cast_castfunc - 1] = ObjectIdGetDatum(funcid);
     values[Anum_pg_cast_castcontext - 1] = CharGetDatum(castcontext);
     values[Anum_pg_cast_castmethod - 1] = CharGetDatum(castmethod);
 
     MemSet(nulls, false, sizeof(nulls));
 
     tuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
 
     castid = CatalogTupleInsert(relation, tuple);
 
     /* make dependency entries */
     myself.classId = CastRelationId;
     myself.objectId = castid;
     myself.objectSubId = 0;
 
     /* dependency on source type */
     referenced.classId = TypeRelationId;
     referenced.objectId = sourcetypeid;
     referenced.objectSubId = 0;
     recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
     /* dependency on target type */
     referenced.classId = TypeRelationId;
     referenced.objectId = targettypeid;
     referenced.objectSubId = 0;
     recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
     /* dependency on function */
     if (OidIsValid(funcid))
     {
         referenced.classId = ProcedureRelationId;
         referenced.objectId = funcid;
         referenced.objectSubId = 0;
         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
     }
 
     /* dependency on extension */
     recordDependencyOnCurrentExtension(&myself, false);
 
     /* Post creation hook for new cast */
     InvokeObjectPostCreateHook(CastRelationId, castid, 0);
 
     heap_freetuple(tuple);
 
     heap_close(relation, RowExclusiveLock);
 
     return myself;
 }

ObjectAddress CreateForeignDataWrapper ( CreateFdwStmt * stmt )

Definition at line 560 of file foreigncmds.c.

References Anum_pg_foreign_data_wrapper_fdwacl, Anum_pg_foreign_data_wrapper_fdwhandler, Anum_pg_foreign_data_wrapper_fdwname, Anum_pg_foreign_data_wrapper_fdwoptions, Anum_pg_foreign_data_wrapper_fdwowner, Anum_pg_foreign_data_wrapper_fdwvalidator, CatalogTupleInsert(), ObjectAddress::classId, CStringGetDatum, DatumGetPointer, DEPENDENCY_NORMAL, DirectFunctionCall1, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errhint(), errmsg(), ERROR, CreateFdwStmt::fdwname, ForeignDataWrapperRelationId, CreateFdwStmt::func_options, GetForeignDataWrapperByName(), GetUserId(), heap_close, heap_form_tuple(), heap_freetuple(), heap_open(), InvokeObjectPostCreateHook, namein(), Natts_pg_foreign_data_wrapper, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, CreateFdwStmt::options, parse_func_options(), PointerGetDatum, PointerIsValid, ProcedureRelationId, RelationData::rd_att, recordDependencyOn(), recordDependencyOnCurrentExtension(), recordDependencyOnOwner(), RowExclusiveLock, superuser(), transformGenericOptions(), and values.

Referenced by ProcessUtilitySlow().

 {
     Relation    rel;
     Datum       values[Natts_pg_foreign_data_wrapper];
     bool        nulls[Natts_pg_foreign_data_wrapper];
     HeapTuple   tuple;
     Oid         fdwId;
     bool        handler_given;
     bool        validator_given;
     Oid         fdwhandler;
     Oid         fdwvalidator;
     Datum       fdwoptions;
     Oid         ownerId;
     ObjectAddress myself;
     ObjectAddress referenced;
 
     rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
 
     /* Must be super user */
     if (!superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("permission denied to create foreign-data wrapper \"%s\"",
                         stmt->fdwname),
                  errhint("Must be superuser to create a foreign-data wrapper.")));
 
     /* For now the owner cannot be specified on create. Use effective user ID. */
     ownerId = GetUserId();
 
     /*
      * Check that there is no other foreign-data wrapper by this name.
      */
     if (GetForeignDataWrapperByName(stmt->fdwname, true) != NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_DUPLICATE_OBJECT),
                  errmsg("foreign-data wrapper \"%s\" already exists",
                         stmt->fdwname)));
 
     /*
      * Insert tuple into pg_foreign_data_wrapper.
      */
     memset(values, 0, sizeof(values));
     memset(nulls, false, sizeof(nulls));
 
     values[Anum_pg_foreign_data_wrapper_fdwname - 1] =
         DirectFunctionCall1(namein, CStringGetDatum(stmt->fdwname));
     values[Anum_pg_foreign_data_wrapper_fdwowner - 1] = ObjectIdGetDatum(ownerId);
 
     /* Lookup handler and validator functions, if given */
     parse_func_options(stmt->func_options,
                        &handler_given, &fdwhandler,
                        &validator_given, &fdwvalidator);
 
     values[Anum_pg_foreign_data_wrapper_fdwhandler - 1] = ObjectIdGetDatum(fdwhandler);
     values[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = ObjectIdGetDatum(fdwvalidator);
 
     nulls[Anum_pg_foreign_data_wrapper_fdwacl - 1] = true;
 
     fdwoptions = transformGenericOptions(ForeignDataWrapperRelationId,
                                          PointerGetDatum(NULL),
                                          stmt->options,
                                          fdwvalidator);
 
     if (PointerIsValid(DatumGetPointer(fdwoptions)))
         values[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = fdwoptions;
     else
         nulls[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;
 
     tuple = heap_form_tuple(rel->rd_att, values, nulls);
 
     fdwId = CatalogTupleInsert(rel, tuple);
 
     heap_freetuple(tuple);
 
     /* record dependencies */
     myself.classId = ForeignDataWrapperRelationId;
     myself.objectId = fdwId;
     myself.objectSubId = 0;
 
     if (OidIsValid(fdwhandler))
     {
         referenced.classId = ProcedureRelationId;
         referenced.objectId = fdwhandler;
         referenced.objectSubId = 0;
         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
     }
 
     if (OidIsValid(fdwvalidator))
     {
         referenced.classId = ProcedureRelationId;
         referenced.objectId = fdwvalidator;
         referenced.objectSubId = 0;
         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
     }
 
     recordDependencyOnOwner(ForeignDataWrapperRelationId, fdwId, ownerId);
 
     /* dependency on extension */
     recordDependencyOnCurrentExtension(&myself, false);
 
     /* Post creation hook for new foreign data wrapper */
     InvokeObjectPostCreateHook(ForeignDataWrapperRelationId, fdwId, 0);
 
     heap_close(rel, RowExclusiveLock);
 
     return myself;
 }

ObjectAddress CreateForeignServer ( CreateForeignServerStmt * stmt )

Definition at line 861 of file foreigncmds.c.

References ACL_KIND_FDW, ACL_USAGE, aclcheck_error(), ACLCHECK_OK, Anum_pg_foreign_server_srvacl, Anum_pg_foreign_server_srvfdw, Anum_pg_foreign_server_srvname, Anum_pg_foreign_server_srvoptions, Anum_pg_foreign_server_srvowner, Anum_pg_foreign_server_srvtype, Anum_pg_foreign_server_srvversion, CatalogTupleInsert(), ObjectAddress::classId, CStringGetDatum, CStringGetTextDatum, DatumGetPointer, DEPENDENCY_NORMAL, DirectFunctionCall1, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, ForeignDataWrapper::fdwid, ForeignDataWrapper::fdwname, CreateForeignServerStmt::fdwname, ForeignDataWrapper::fdwvalidator, ForeignDataWrapperRelationId, ForeignServerRelationId, GetForeignDataWrapperByName(), GetForeignServerByName(), GetUserId(), heap_close, heap_form_tuple(), heap_freetuple(), heap_open(), CreateForeignServerStmt::if_not_exists, InvalidObjectAddress, InvokeObjectPostCreateHook, namein(), Natts_pg_foreign_server, NOTICE, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, CreateForeignServerStmt::options, pg_foreign_data_wrapper_aclcheck(), PointerGetDatum, PointerIsValid, RelationData::rd_att, recordDependencyOn(), recordDependencyOnCurrentExtension(), recordDependencyOnOwner(), RowExclusiveLock, CreateForeignServerStmt::servername, CreateForeignServerStmt::servertype, transformGenericOptions(), values, and CreateForeignServerStmt::version.

Referenced by ProcessUtilitySlow().

 {
     Relation    rel;
     Datum       srvoptions;
     Datum       values[Natts_pg_foreign_server];
     bool        nulls[Natts_pg_foreign_server];
     HeapTuple   tuple;
     Oid         srvId;
     Oid         ownerId;
     AclResult   aclresult;
     ObjectAddress myself;
     ObjectAddress referenced;
     ForeignDataWrapper *fdw;
 
     rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
 
     /* For now the owner cannot be specified on create. Use effective user ID. */
     ownerId = GetUserId();
 
     /*
      * Check that there is no other foreign server by this name. Do nothing if
      * IF NOT EXISTS was enforced.
      */
     if (GetForeignServerByName(stmt->servername, true) != NULL)
     {
         if (stmt->if_not_exists)
         {
             ereport(NOTICE,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("server \"%s\" already exists, skipping",
                             stmt->servername)));
             heap_close(rel, RowExclusiveLock);
             return InvalidObjectAddress;
         }
         else
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("server \"%s\" already exists",
                             stmt->servername)));
     }
 
     /*
      * Check that the FDW exists and that we have USAGE on it. Also get the
      * actual FDW for option validation etc.
      */
     fdw = GetForeignDataWrapperByName(stmt->fdwname, false);
 
     aclresult = pg_foreign_data_wrapper_aclcheck(fdw->fdwid, ownerId, ACL_USAGE);
     if (aclresult != ACLCHECK_OK)
         aclcheck_error(aclresult, ACL_KIND_FDW, fdw->fdwname);
 
     /*
      * Insert tuple into pg_foreign_server.
      */
     memset(values, 0, sizeof(values));
     memset(nulls, false, sizeof(nulls));
 
     values[Anum_pg_foreign_server_srvname - 1] =
         DirectFunctionCall1(namein, CStringGetDatum(stmt->servername));
     values[Anum_pg_foreign_server_srvowner - 1] = ObjectIdGetDatum(ownerId);
     values[Anum_pg_foreign_server_srvfdw - 1] = ObjectIdGetDatum(fdw->fdwid);
 
     /* Add server type if supplied */
     if (stmt->servertype)
         values[Anum_pg_foreign_server_srvtype - 1] =
             CStringGetTextDatum(stmt->servertype);
     else
         nulls[Anum_pg_foreign_server_srvtype - 1] = true;
 
     /* Add server version if supplied */
     if (stmt->version)
         values[Anum_pg_foreign_server_srvversion - 1] =
             CStringGetTextDatum(stmt->version);
     else
         nulls[Anum_pg_foreign_server_srvversion - 1] = true;
 
     /* Start with a blank acl */
     nulls[Anum_pg_foreign_server_srvacl - 1] = true;
 
     /* Add server options */
     srvoptions = transformGenericOptions(ForeignServerRelationId,
                                          PointerGetDatum(NULL),
                                          stmt->options,
                                          fdw->fdwvalidator);
 
     if (PointerIsValid(DatumGetPointer(srvoptions)))
         values[Anum_pg_foreign_server_srvoptions - 1] = srvoptions;
     else
         nulls[Anum_pg_foreign_server_srvoptions - 1] = true;
 
     tuple = heap_form_tuple(rel->rd_att, values, nulls);
 
     srvId = CatalogTupleInsert(rel, tuple);
 
     heap_freetuple(tuple);
 
     /* record dependencies */
     myself.classId = ForeignServerRelationId;
     myself.objectId = srvId;
     myself.objectSubId = 0;
 
     referenced.classId = ForeignDataWrapperRelationId;
     referenced.objectId = fdw->fdwid;
     referenced.objectSubId = 0;
     recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
     recordDependencyOnOwner(ForeignServerRelationId, srvId, ownerId);
 
     /* dependency on extension */
     recordDependencyOnCurrentExtension(&myself, false);
 
     /* Post creation hook for new foreign server */
     InvokeObjectPostCreateHook(ForeignServerRelationId, srvId, 0);
 
     heap_close(rel, RowExclusiveLock);
 
     return myself;
 }

void CreateForeignTable	(	CreateForeignTableStmt *	stmt,
		Oid	relid
	)

Definition at line 1446 of file foreigncmds.c.

References ACL_KIND_FOREIGN_SERVER, ACL_USAGE, aclcheck_error(), ACLCHECK_OK, Anum_pg_foreign_table_ftoptions, Anum_pg_foreign_table_ftrelid, Anum_pg_foreign_table_ftserver, CatalogTupleInsert(), ObjectAddress::classId, CommandCounterIncrement(), DatumGetPointer, DEPENDENCY_NORMAL, ForeignServer::fdwid, ForeignDataWrapper::fdwvalidator, ForeignServerRelationId, ForeignTableRelationId, GetForeignDataWrapper(), GetForeignServerByName(), GetUserId(), heap_close, heap_form_tuple(), heap_freetuple(), heap_open(), Natts_pg_foreign_table, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, CreateForeignTableStmt::options, pg_foreign_server_aclcheck(), PointerGetDatum, PointerIsValid, RelationData::rd_att, recordDependencyOn(), RelationRelationId, RowExclusiveLock, ForeignServer::serverid, ForeignServer::servername, CreateForeignTableStmt::servername, transformGenericOptions(), and values.

Referenced by ProcessUtilitySlow().

 {
     Relation    ftrel;
     Datum       ftoptions;
     Datum       values[Natts_pg_foreign_table];
     bool        nulls[Natts_pg_foreign_table];
     HeapTuple   tuple;
     AclResult   aclresult;
     ObjectAddress myself;
     ObjectAddress referenced;
     Oid         ownerId;
     ForeignDataWrapper *fdw;
     ForeignServer *server;
 
     /*
      * Advance command counter to ensure the pg_attribute tuple is visible;
      * the tuple might be updated to add constraints in previous step.
      */
     CommandCounterIncrement();
 
     ftrel = heap_open(ForeignTableRelationId, RowExclusiveLock);
 
     /*
      * For now the owner cannot be specified on create. Use effective user ID.
      */
     ownerId = GetUserId();
 
     /*
      * Check that the foreign server exists and that we have USAGE on it. Also
      * get the actual FDW for option validation etc.
      */
     server = GetForeignServerByName(stmt->servername, false);
     aclresult = pg_foreign_server_aclcheck(server->serverid, ownerId, ACL_USAGE);
     if (aclresult != ACLCHECK_OK)
         aclcheck_error(aclresult, ACL_KIND_FOREIGN_SERVER, server->servername);
 
     fdw = GetForeignDataWrapper(server->fdwid);
 
     /*
      * Insert tuple into pg_foreign_table.
      */
     memset(values, 0, sizeof(values));
     memset(nulls, false, sizeof(nulls));
 
     values[Anum_pg_foreign_table_ftrelid - 1] = ObjectIdGetDatum(relid);
     values[Anum_pg_foreign_table_ftserver - 1] = ObjectIdGetDatum(server->serverid);
     /* Add table generic options */
     ftoptions = transformGenericOptions(ForeignTableRelationId,
                                         PointerGetDatum(NULL),
                                         stmt->options,
                                         fdw->fdwvalidator);
 
     if (PointerIsValid(DatumGetPointer(ftoptions)))
         values[Anum_pg_foreign_table_ftoptions - 1] = ftoptions;
     else
         nulls[Anum_pg_foreign_table_ftoptions - 1] = true;
 
     tuple = heap_form_tuple(ftrel->rd_att, values, nulls);
 
     CatalogTupleInsert(ftrel, tuple);
 
     heap_freetuple(tuple);
 
     /* Add pg_class dependency on the server */
     myself.classId = RelationRelationId;
     myself.objectId = relid;
     myself.objectSubId = 0;
 
     referenced.classId = ForeignServerRelationId;
     referenced.objectId = server->serverid;
     referenced.objectSubId = 0;
     recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
     heap_close(ftrel, RowExclusiveLock);
 }

ObjectAddress CreateFunction	(	ParseState *	pstate,
		CreateFunctionStmt *	stmt
	)

Definition at line 861 of file functioncmds.c.

References ACL_CREATE, ACL_KIND_LANGUAGE, ACL_KIND_NAMESPACE, ACL_USAGE, aclcheck_error(), ACLCHECK_NO_PRIV, ACLCHECK_OK, castNode, ClanguageId, compute_attributes_sql_style(), compute_attributes_with_style(), compute_return_type(), construct_array(), ereport, errcode(), errhint(), errmsg(), ERROR, format_type_be(), CreateFunctionStmt::funcname, get_base_element_type(), get_namespace_name(), get_transform_oid(), GETSTRUCT, GetUserId(), HeapTupleGetOid, HeapTupleIsValid, i, INTERNALlanguageId, interpret_AS_clause(), interpret_function_parameter_list(), LANGNAME, lappend_oid(), lfirst_node, lfirst_oid, list_length(), NameStr, NIL, ObjectIdGetDatum, OidIsValid, OIDOID, CreateFunctionStmt::options, palloc(), CreateFunctionStmt::parameters, pg_language_aclcheck(), pg_namespace_aclcheck(), PLTemplateExists(), PointerGetDatum, ProcedureCreate(), PROPARALLEL_UNSAFE, PROVOLATILE_VOLATILE, QualifiedNameGetCreationNamespace(), ReleaseSysCache(), CreateFunctionStmt::replace, CreateFunctionStmt::returnType, SearchSysCache1, superuser(), typenameTypeId(), VOIDOID, and CreateFunctionStmt::withClause.

Referenced by ProcessUtilitySlow().

 {
     char       *probin_str;
     char       *prosrc_str;
     Oid         prorettype;
     bool        returnsSet;
     char       *language;
     Oid         languageOid;
     Oid         languageValidator;
     Node       *transformDefElem = NULL;
     char       *funcname;
     Oid         namespaceId;
     AclResult   aclresult;
     oidvector  *parameterTypes;
     ArrayType  *allParameterTypes;
     ArrayType  *parameterModes;
     ArrayType  *parameterNames;
     List       *parameterDefaults;
     Oid         variadicArgType;
     List       *trftypes_list = NIL;
     ArrayType  *trftypes;
     Oid         requiredResultType;
     bool        isWindowFunc,
                 isStrict,
                 security,
                 isLeakProof;
     char        volatility;
     ArrayType  *proconfig;
     float4      procost;
     float4      prorows;
     HeapTuple   languageTuple;
     Form_pg_language languageStruct;
     List       *as_clause;
     char        parallel;
 
     /* Convert list of names to a name and namespace */
     namespaceId = QualifiedNameGetCreationNamespace(stmt->funcname,
                                                     &funcname);
 
     /* Check we have creation rights in target namespace */
     aclresult = pg_namespace_aclcheck(namespaceId, GetUserId(), ACL_CREATE);
     if (aclresult != ACLCHECK_OK)
         aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
                        get_namespace_name(namespaceId));
 
     /* default attributes */
     isWindowFunc = false;
     isStrict = false;
     security = false;
     isLeakProof = false;
     volatility = PROVOLATILE_VOLATILE;
     proconfig = NULL;
     procost = -1;               /* indicates not set */
     prorows = -1;               /* indicates not set */
     parallel = PROPARALLEL_UNSAFE;
 
     /* override attributes from explicit list */
     compute_attributes_sql_style(pstate,
                                  stmt->options,
                                  &as_clause, &language, &transformDefElem,
                                  &isWindowFunc, &volatility,
                                  &isStrict, &security, &isLeakProof,
                                  &proconfig, &procost, &prorows, &parallel);
 
     /* Look up the language and validate permissions */
     languageTuple = SearchSysCache1(LANGNAME, PointerGetDatum(language));
     if (!HeapTupleIsValid(languageTuple))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("language \"%s\" does not exist", language),
                  (PLTemplateExists(language) ?
                   errhint("Use CREATE LANGUAGE to load the language into the database.") : 0)));
 
     languageOid = HeapTupleGetOid(languageTuple);
     languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
 
     if (languageStruct->lanpltrusted)
     {
         /* if trusted language, need USAGE privilege */
         AclResult   aclresult;
 
         aclresult = pg_language_aclcheck(languageOid, GetUserId(), ACL_USAGE);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, ACL_KIND_LANGUAGE,
                            NameStr(languageStruct->lanname));
     }
     else
     {
         /* if untrusted language, must be superuser */
         if (!superuser())
             aclcheck_error(ACLCHECK_NO_PRIV, ACL_KIND_LANGUAGE,
                            NameStr(languageStruct->lanname));
     }
 
     languageValidator = languageStruct->lanvalidator;
 
     ReleaseSysCache(languageTuple);
 
     /*
      * Only superuser is allowed to create leakproof functions because
      * leakproof functions can see tuples which have not yet been filtered out
      * by security barrier views or row level security policies.
      */
     if (isLeakProof && !superuser())
         ereport(ERROR,
                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                  errmsg("only superuser can define a leakproof function")));
 
     if (transformDefElem)
     {
         ListCell   *lc;
 
         foreach(lc, castNode(List, transformDefElem))
         {
             Oid         typeid = typenameTypeId(NULL,
                                                 lfirst_node(TypeName, lc));
             Oid         elt = get_base_element_type(typeid);
 
             typeid = elt ? elt : typeid;
 
             get_transform_oid(typeid, languageOid, false);
             trftypes_list = lappend_oid(trftypes_list, typeid);
         }
     }
 
     /*
      * Convert remaining parameters of CREATE to form wanted by
      * ProcedureCreate.
      */
     interpret_function_parameter_list(pstate,
                                       stmt->parameters,
                                       languageOid,
                                       false,    /* not an aggregate */
                                       &parameterTypes,
                                       &allParameterTypes,
                                       &parameterModes,
                                       &parameterNames,
                                       &parameterDefaults,
                                       &variadicArgType,
                                       &requiredResultType);
 
     if (stmt->returnType)
     {
         /* explicit RETURNS clause */
         compute_return_type(stmt->returnType, languageOid,
                             &prorettype, &returnsSet);
         if (OidIsValid(requiredResultType) && prorettype != requiredResultType)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("function result type must be %s because of OUT parameters",
                             format_type_be(requiredResultType))));
     }
     else if (OidIsValid(requiredResultType))
     {
         /* default RETURNS clause from OUT parameters */
         prorettype = requiredResultType;
         returnsSet = false;
     }
     else
     {
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                  errmsg("function result type must be specified")));
         /* Alternative possibility: default to RETURNS VOID */
         prorettype = VOIDOID;
         returnsSet = false;
     }
 
     if (list_length(trftypes_list) > 0)
     {
         ListCell   *lc;
         Datum      *arr;
         int         i;
 
         arr = palloc(list_length(trftypes_list) * sizeof(Datum));
         i = 0;
         foreach(lc, trftypes_list)
             arr[i++] = ObjectIdGetDatum(lfirst_oid(lc));
         trftypes = construct_array(arr, list_length(trftypes_list),
                                    OIDOID, sizeof(Oid), true, 'i');
     }
     else
     {
         /* store SQL NULL instead of empty array */
         trftypes = NULL;
     }
 
     compute_attributes_with_style(pstate, stmt->withClause, &isStrict, &volatility);
 
     interpret_AS_clause(languageOid, language, funcname, as_clause,
                         &prosrc_str, &probin_str);
 
     /*
      * Set default values for COST and ROWS depending on other parameters;
      * reject ROWS if it's not returnsSet.  NB: pg_dump knows these default
      * values, keep it in sync if you change them.
      */
     if (procost < 0)
     {
         /* SQL and PL-language functions are assumed more expensive */
         if (languageOid == INTERNALlanguageId ||
             languageOid == ClanguageId)
             procost = 1;
         else
             procost = 100;
     }
     if (prorows < 0)
     {
         if (returnsSet)
             prorows = 1000;
         else
             prorows = 0;        /* dummy value if not returnsSet */
     }
     else if (!returnsSet)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("ROWS is not applicable when function does not return a set")));
 
     /*
      * And now that we have all the parameters, and know we're permitted to do
      * so, go ahead and create the function.
      */
     return ProcedureCreate(funcname,
                            namespaceId,
                            stmt->replace,
                            returnsSet,
                            prorettype,
                            GetUserId(),
                            languageOid,
                            languageValidator,
                            prosrc_str,  /* converted to text later */
                            probin_str,  /* converted to text later */
                            false,   /* not an aggregate */
                            isWindowFunc,
                            security,
                            isLeakProof,
                            isStrict,
                            volatility,
                            parallel,
                            parameterTypes,
                            PointerGetDatum(allParameterTypes),
                            PointerGetDatum(parameterModes),
                            PointerGetDatum(parameterNames),
                            parameterDefaults,
                            PointerGetDatum(trftypes),
                            PointerGetDatum(proconfig),
                            procost,
                            prorows);
 }

ObjectAddress CreateStatistics ( CreateStatsStmt * stmt )

Definition at line 49 of file statscmds.c.

Referenced by ProcessUtilitySlow().

 {
     int16       attnums[STATS_MAX_DIMENSIONS];
     int         numcols = 0;
     char       *namestr;
     NameData    stxname;
     Oid         statoid;
     Oid         namespaceId;
     Oid         stxowner = GetUserId();
     HeapTuple   htup;
     Datum       values[Natts_pg_statistic_ext];
     bool        nulls[Natts_pg_statistic_ext];
     int2vector *stxkeys;
     Relation    statrel;
     Relation    rel = NULL;
     Oid         relid;
     ObjectAddress parentobject,
                 myself;
     Datum       types[2];       /* one for each possible type of statistic */
     int         ntypes;
     ArrayType  *stxkind;
     bool        build_ndistinct;
     bool        build_dependencies;
     bool        requested_type = false;
     int         i;
     ListCell   *cell;
 
     Assert(IsA(stmt, CreateStatsStmt));
 
     /* resolve the pieces of the name (namespace etc.) */
     namespaceId = QualifiedNameGetCreationNamespace(stmt->defnames, &namestr);
     namestrcpy(&stxname, namestr);
 
     /*
      * Deal with the possibility that the statistics object already exists.
      */
     if (SearchSysCacheExists2(STATEXTNAMENSP,
                               NameGetDatum(&stxname),
                               ObjectIdGetDatum(namespaceId)))
     {
         if (stmt->if_not_exists)
         {
             ereport(NOTICE,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("statistics object \"%s\" already exists, skipping",
                             namestr)));
             return InvalidObjectAddress;
         }
 
         ereport(ERROR,
                 (errcode(ERRCODE_DUPLICATE_OBJECT),
                  errmsg("statistics object \"%s\" already exists", namestr)));
     }
 
     /*
      * Examine the FROM clause.  Currently, we only allow it to be a single
      * simple table, but later we'll probably allow multiple tables and JOIN
      * syntax.  The grammar is already prepared for that, so we have to check
      * here that what we got is what we can support.
      */
     if (list_length(stmt->relations) != 1)
         ereport(ERROR,
                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                  errmsg("only a single relation is allowed in CREATE STATISTICS")));
 
     foreach(cell, stmt->relations)
     {
         Node       *rln = (Node *) lfirst(cell);
 
         if (!IsA(rln, RangeVar))
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("only a single relation is allowed in CREATE STATISTICS")));
 
         /*
          * CREATE STATISTICS will influence future execution plans but does
          * not interfere with currently executing plans.  So it should be
          * enough to take only ShareUpdateExclusiveLock on relation,
          * conflicting with ANALYZE and other DDL that sets statistical
          * information, but not with normal queries.
          */
         rel = relation_openrv((RangeVar *) rln, ShareUpdateExclusiveLock);
 
         /* Restrict to allowed relation types */
         if (rel->rd_rel->relkind != RELKIND_RELATION &&
             rel->rd_rel->relkind != RELKIND_MATVIEW &&
             rel->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
             rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
             ereport(ERROR,
                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                      errmsg("relation \"%s\" is not a table, foreign table, or materialized view",
                             RelationGetRelationName(rel))));
 
         /* You must own the relation to create stats on it */
         if (!pg_class_ownercheck(RelationGetRelid(rel), stxowner))
             aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CLASS,
                            RelationGetRelationName(rel));
     }
 
     Assert(rel);
     relid = RelationGetRelid(rel);
 
     /*
      * Currently, we only allow simple column references in the expression
      * list.  That will change someday, and again the grammar already supports
      * it so we have to enforce restrictions here.  For now, we can convert
      * the expression list to a simple array of attnums.  While at it, enforce
      * some constraints.
      */
     foreach(cell, stmt->exprs)
     {
         Node       *expr = (Node *) lfirst(cell);
         ColumnRef  *cref;
         char       *attname;
         HeapTuple   atttuple;
         Form_pg_attribute attForm;
         TypeCacheEntry *type;
 
         if (!IsA(expr, ColumnRef))
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("only simple column references are allowed in CREATE STATISTICS")));
         cref = (ColumnRef *) expr;
 
         if (list_length(cref->fields) != 1)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("only simple column references are allowed in CREATE STATISTICS")));
         attname = strVal((Value *) linitial(cref->fields));
 
         atttuple = SearchSysCacheAttName(relid, attname);
         if (!HeapTupleIsValid(atttuple))
             ereport(ERROR,
                     (errcode(ERRCODE_UNDEFINED_COLUMN),
                      errmsg("column \"%s\" does not exist",
                             attname)));
         attForm = (Form_pg_attribute) GETSTRUCT(atttuple);
 
         /* Disallow use of system attributes in extended stats */
         if (attForm->attnum <= 0)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("statistics creation on system columns is not supported")));
 
         /* Disallow data types without a less-than operator */
         type = lookup_type_cache(attForm->atttypid, TYPECACHE_LT_OPR);
         if (type->lt_opr == InvalidOid)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("column \"%s\" cannot be used in statistics because its type %s has no default btree operator class",
                             attname, format_type_be(attForm->atttypid))));
 
         /* Make sure no more than STATS_MAX_DIMENSIONS columns are used */
         if (numcols >= STATS_MAX_DIMENSIONS)
             ereport(ERROR,
                     (errcode(ERRCODE_TOO_MANY_COLUMNS),
                      errmsg("cannot have more than %d columns in statistics",
                             STATS_MAX_DIMENSIONS)));
 
         attnums[numcols] = attForm->attnum;
         numcols++;
         ReleaseSysCache(atttuple);
     }
 
     /*
      * Check that at least two columns were specified in the statement. The
      * upper bound was already checked in the loop above.
      */
     if (numcols < 2)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                  errmsg("extended statistics require at least 2 columns")));
 
     /*
      * Sort the attnums, which makes detecting duplicates somewhat easier, and
      * it does not hurt (it does not affect the efficiency, unlike for
      * indexes, for example).
      */
     qsort(attnums, numcols, sizeof(int16), compare_int16);
 
     /*
      * Check for duplicates in the list of columns. The attnums are sorted so
      * just check consecutive elements.
      */
     for (i = 1; i < numcols; i++)
     {
         if (attnums[i] == attnums[i - 1])
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_COLUMN),
                      errmsg("duplicate column name in statistics definition")));
     }
 
     /* Form an int2vector representation of the sorted column list */
     stxkeys = buildint2vector(attnums, numcols);
 
     /*
      * Parse the statistics kinds.
      */
     build_ndistinct = false;
     build_dependencies = false;
     foreach(cell, stmt->stat_types)
     {
         char       *type = strVal((Value *) lfirst(cell));
 
         if (strcmp(type, "ndistinct") == 0)
         {
             build_ndistinct = true;
             requested_type = true;
         }
         else if (strcmp(type, "dependencies") == 0)
         {
             build_dependencies = true;
             requested_type = true;
         }
         else
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("unrecognized statistics kind \"%s\"",
                             type)));
     }
     /* If no statistic type was specified, build them all. */
     if (!requested_type)
     {
         build_ndistinct = true;
         build_dependencies = true;
     }
 
     /* construct the char array of enabled statistic types */
     ntypes = 0;
     if (build_ndistinct)
         types[ntypes++] = CharGetDatum(STATS_EXT_NDISTINCT);
     if (build_dependencies)
         types[ntypes++] = CharGetDatum(STATS_EXT_DEPENDENCIES);
     Assert(ntypes > 0 && ntypes <= lengthof(types));
     stxkind = construct_array(types, ntypes, CHAROID, 1, true, 'c');
 
     /*
      * Everything seems fine, so let's build the pg_statistic_ext tuple.
      */
     memset(values, 0, sizeof(values));
     memset(nulls, false, sizeof(nulls));
     values[Anum_pg_statistic_ext_stxrelid - 1] = ObjectIdGetDatum(relid);
     values[Anum_pg_statistic_ext_stxname - 1] = NameGetDatum(&stxname);
     values[Anum_pg_statistic_ext_stxnamespace - 1] = ObjectIdGetDatum(namespaceId);
     values[Anum_pg_statistic_ext_stxowner - 1] = ObjectIdGetDatum(stxowner);
     values[Anum_pg_statistic_ext_stxkeys - 1] = PointerGetDatum(stxkeys);
     values[Anum_pg_statistic_ext_stxkind - 1] = PointerGetDatum(stxkind);
 
     /* no statistics built yet */
     nulls[Anum_pg_statistic_ext_stxndistinct - 1] = true;
     nulls[Anum_pg_statistic_ext_stxdependencies - 1] = true;
 
     /* insert it into pg_statistic_ext */
     statrel = heap_open(StatisticExtRelationId, RowExclusiveLock);
     htup = heap_form_tuple(statrel->rd_att, values, nulls);
     statoid = CatalogTupleInsert(statrel, htup);
     heap_freetuple(htup);
     relation_close(statrel, RowExclusiveLock);
 
     /*
      * Invalidate relcache so that others see the new statistics object.
      */
     CacheInvalidateRelcache(rel);
 
     relation_close(rel, NoLock);
 
     /*
      * Add an AUTO dependency on each column used in the stats, so that the
      * stats object goes away if any or all of them get dropped.
      */
     ObjectAddressSet(myself, StatisticExtRelationId, statoid);
 
     for (i = 0; i < numcols; i++)
     {
         ObjectAddressSubSet(parentobject, RelationRelationId, relid, attnums[i]);
         recordDependencyOn(&myself, &parentobject, DEPENDENCY_AUTO);
     }
 
     /*
      * Also add dependencies on namespace and owner.  These are required
      * because the stats object might have a different namespace and/or owner
      * than the underlying table(s).
      */
     ObjectAddressSet(parentobject, NamespaceRelationId, namespaceId);
     recordDependencyOn(&myself, &parentobject, DEPENDENCY_NORMAL);
 
     recordDependencyOnOwner(StatisticExtRelationId, statoid, stxowner);
 
     /*
      * XXX probably there should be a recordDependencyOnCurrentExtension call
      * here too, but we'd have to add support for ALTER EXTENSION ADD/DROP
      * STATISTICS, which is more work than it seems worth.
      */
 
     /* Return stats object's address */
     return myself;
 }

ObjectAddress CreateTransform ( CreateTransformStmt * stmt )

Definition at line 1797 of file functioncmds.c.

References ACL_EXECUTE, ACL_KIND_LANGUAGE, ACL_KIND_PROC, ACL_USAGE, aclcheck_error(), aclcheck_error_type(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, Anum_pg_transform_trffromsql, Anum_pg_transform_trflang, Anum_pg_transform_trftosql, Anum_pg_transform_trftype, CatalogTupleInsert(), CatalogTupleUpdate(), check_transform_function(), ObjectAddress::classId, deleteDependencyRecordsFor(), DEPENDENCY_NORMAL, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, format_type_be(), CreateTransformStmt::fromsql, get_language_oid(), get_typtype(), GETSTRUCT, GetUserId(), heap_close, heap_form_tuple(), heap_freetuple(), heap_modify_tuple(), heap_open(), HeapTupleGetOid, HeapTupleIsValid, INTERNALOID, InvalidOid, InvokeObjectPostCreateHook, CreateTransformStmt::lang, LanguageRelationId, LookupFuncWithArgs(), MemSet, NameListToString(), Natts_pg_transform, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, ObjectWithArgs::objname, OidIsValid, pg_language_aclcheck(), pg_proc_aclcheck(), pg_proc_ownercheck(), pg_type_aclcheck(), pg_type_ownercheck(), ProcedureRelationId, PROCOID, recordDependencyOn(), recordDependencyOnCurrentExtension(), RelationGetDescr, ReleaseSysCache(), CreateTransformStmt::replace, RowExclusiveLock, SearchSysCache1, SearchSysCache2, HeapTupleData::t_self, CreateTransformStmt::tosql, TransformRelationId, TRFTYPELANG, CreateTransformStmt::type_name, TypeNameToString(), typenameTypeId(), TypeRelationId, TYPTYPE_DOMAIN, TYPTYPE_PSEUDO, and values.

Referenced by ProcessUtilitySlow().

 {
     Oid         typeid;
     char        typtype;
     Oid         langid;
     Oid         fromsqlfuncid;
     Oid         tosqlfuncid;
     AclResult   aclresult;
     Form_pg_proc procstruct;
     Datum       values[Natts_pg_transform];
     bool        nulls[Natts_pg_transform];
     bool        replaces[Natts_pg_transform];
     Oid         transformid;
     HeapTuple   tuple;
     HeapTuple   newtuple;
     Relation    relation;
     ObjectAddress myself,
                 referenced;
     bool        is_replace;
 
     /*
      * Get the type
      */
     typeid = typenameTypeId(NULL, stmt->type_name);
     typtype = get_typtype(typeid);
 
     if (typtype == TYPTYPE_PSEUDO)
         ereport(ERROR,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("data type %s is a pseudo-type",
                         TypeNameToString(stmt->type_name))));
 
     if (typtype == TYPTYPE_DOMAIN)
         ereport(ERROR,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("data type %s is a domain",
                         TypeNameToString(stmt->type_name))));
 
     if (!pg_type_ownercheck(typeid, GetUserId()))
         aclcheck_error_type(ACLCHECK_NOT_OWNER, typeid);
 
     aclresult = pg_type_aclcheck(typeid, GetUserId(), ACL_USAGE);
     if (aclresult != ACLCHECK_OK)
         aclcheck_error_type(aclresult, typeid);
 
     /*
      * Get the language
      */
     langid = get_language_oid(stmt->lang, false);
 
     aclresult = pg_language_aclcheck(langid, GetUserId(), ACL_USAGE);
     if (aclresult != ACLCHECK_OK)
         aclcheck_error(aclresult, ACL_KIND_LANGUAGE, stmt->lang);
 
     /*
      * Get the functions
      */
     if (stmt->fromsql)
     {
         fromsqlfuncid = LookupFuncWithArgs(stmt->fromsql, false);
 
         if (!pg_proc_ownercheck(fromsqlfuncid, GetUserId()))
             aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_PROC, NameListToString(stmt->fromsql->objname));
 
         aclresult = pg_proc_aclcheck(fromsqlfuncid, GetUserId(), ACL_EXECUTE);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, ACL_KIND_PROC, NameListToString(stmt->fromsql->objname));
 
         tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(fromsqlfuncid));
         if (!HeapTupleIsValid(tuple))
             elog(ERROR, "cache lookup failed for function %u", fromsqlfuncid);
         procstruct = (Form_pg_proc) GETSTRUCT(tuple);
         if (procstruct->prorettype != INTERNALOID)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("return data type of FROM SQL function must be %s",
                             "internal")));
         check_transform_function(procstruct);
         ReleaseSysCache(tuple);
     }
     else
         fromsqlfuncid = InvalidOid;
 
     if (stmt->tosql)
     {
         tosqlfuncid = LookupFuncWithArgs(stmt->tosql, false);
 
         if (!pg_proc_ownercheck(tosqlfuncid, GetUserId()))
             aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_PROC, NameListToString(stmt->tosql->objname));
 
         aclresult = pg_proc_aclcheck(tosqlfuncid, GetUserId(), ACL_EXECUTE);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, ACL_KIND_PROC, NameListToString(stmt->tosql->objname));
 
         tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(tosqlfuncid));
         if (!HeapTupleIsValid(tuple))
             elog(ERROR, "cache lookup failed for function %u", tosqlfuncid);
         procstruct = (Form_pg_proc) GETSTRUCT(tuple);
         if (procstruct->prorettype != typeid)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("return data type of TO SQL function must be the transform data type")));
         check_transform_function(procstruct);
         ReleaseSysCache(tuple);
     }
     else
         tosqlfuncid = InvalidOid;
 
     /*
      * Ready to go
      */
     values[Anum_pg_transform_trftype - 1] = ObjectIdGetDatum(typeid);
     values[Anum_pg_transform_trflang - 1] = ObjectIdGetDatum(langid);
     values[Anum_pg_transform_trffromsql - 1] = ObjectIdGetDatum(fromsqlfuncid);
     values[Anum_pg_transform_trftosql - 1] = ObjectIdGetDatum(tosqlfuncid);
 
     MemSet(nulls, false, sizeof(nulls));
 
     relation = heap_open(TransformRelationId, RowExclusiveLock);
 
     tuple = SearchSysCache2(TRFTYPELANG,
                             ObjectIdGetDatum(typeid),
                             ObjectIdGetDatum(langid));
     if (HeapTupleIsValid(tuple))
     {
         if (!stmt->replace)
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("transform for type %s language \"%s\" already exists",
                             format_type_be(typeid),
                             stmt->lang)));
 
         MemSet(replaces, false, sizeof(replaces));
         replaces[Anum_pg_transform_trffromsql - 1] = true;
         replaces[Anum_pg_transform_trftosql - 1] = true;
 
         newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values, nulls, replaces);
         CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
 
         transformid = HeapTupleGetOid(tuple);
         ReleaseSysCache(tuple);
         is_replace = true;
     }
     else
     {
         newtuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
         transformid = CatalogTupleInsert(relation, newtuple);
         is_replace = false;
     }
 
     if (is_replace)
         deleteDependencyRecordsFor(TransformRelationId, transformid, true);
 
     /* make dependency entries */
     myself.classId = TransformRelationId;
     myself.objectId = transformid;
     myself.objectSubId = 0;
 
     /* dependency on language */
     referenced.classId = LanguageRelationId;
     referenced.objectId = langid;
     referenced.objectSubId = 0;
     recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
     /* dependency on type */
     referenced.classId = TypeRelationId;
     referenced.objectId = typeid;
     referenced.objectSubId = 0;
     recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
     /* dependencies on functions */
     if (OidIsValid(fromsqlfuncid))
     {
         referenced.classId = ProcedureRelationId;
         referenced.objectId = fromsqlfuncid;
         referenced.objectSubId = 0;
         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
     }
     if (OidIsValid(tosqlfuncid))
     {
         referenced.classId = ProcedureRelationId;
         referenced.objectId = tosqlfuncid;
         referenced.objectSubId = 0;
         recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
     }
 
     /* dependency on extension */
     recordDependencyOnCurrentExtension(&myself, is_replace);
 
     /* Post creation hook for new transform */
     InvokeObjectPostCreateHook(TransformRelationId, transformid, 0);
 
     heap_freetuple(newtuple);
 
     heap_close(relation, RowExclusiveLock);
 
     return myself;
 }

ObjectAddress CreateUserMapping ( CreateUserMappingStmt * stmt )

Definition at line 1135 of file foreigncmds.c.

References ACL_ID_PUBLIC, Anum_pg_user_mapping_umoptions, Anum_pg_user_mapping_umserver, Anum_pg_user_mapping_umuser, CatalogTupleInsert(), ObjectAddress::classId, DatumGetPointer, DEPENDENCY_NORMAL, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, ForeignServer::fdwid, ForeignDataWrapper::fdwvalidator, ForeignServerRelationId, get_rolespec_oid(), GetForeignDataWrapper(), GetForeignServerByName(), GetSysCacheOid2, heap_close, heap_form_tuple(), heap_freetuple(), heap_open(), CreateUserMappingStmt::if_not_exists, InvalidObjectAddress, InvokeObjectPostCreateHook, MappingUserName, Natts_pg_user_mapping, NOTICE, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, CreateUserMappingStmt::options, PointerGetDatum, PointerIsValid, RelationData::rd_att, recordDependencyOn(), recordDependencyOnCurrentExtension(), recordDependencyOnOwner(), ROLESPEC_PUBLIC, RoleSpec::roletype, RowExclusiveLock, ForeignServer::serverid, CreateUserMappingStmt::servername, transformGenericOptions(), CreateUserMappingStmt::user, user_mapping_ddl_aclcheck(), UserMappingRelationId, and values.

Referenced by ProcessUtilitySlow().

 {
     Relation    rel;
     Datum       useoptions;
     Datum       values[Natts_pg_user_mapping];
     bool        nulls[Natts_pg_user_mapping];
     HeapTuple   tuple;
     Oid         useId;
     Oid         umId;
     ObjectAddress myself;
     ObjectAddress referenced;
     ForeignServer *srv;
     ForeignDataWrapper *fdw;
     RoleSpec   *role = (RoleSpec *) stmt->user;
 
     rel = heap_open(UserMappingRelationId, RowExclusiveLock);
 
     if (role->roletype == ROLESPEC_PUBLIC)
         useId = ACL_ID_PUBLIC;
     else
         useId = get_rolespec_oid(stmt->user, false);
 
     /* Check that the server exists. */
     srv = GetForeignServerByName(stmt->servername, false);
 
     user_mapping_ddl_aclcheck(useId, srv->serverid, stmt->servername);
 
     /*
      * Check that the user mapping is unique within server.
      */
     umId = GetSysCacheOid2(USERMAPPINGUSERSERVER,
                            ObjectIdGetDatum(useId),
                            ObjectIdGetDatum(srv->serverid));
 
     if (OidIsValid(umId))
     {
         if (stmt->if_not_exists)
         {
             ereport(NOTICE,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("user mapping for \"%s\" already exists for server %s, skipping",
                             MappingUserName(useId),
                             stmt->servername)));
 
             heap_close(rel, RowExclusiveLock);
             return InvalidObjectAddress;
         }
         else
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("user mapping for \"%s\" already exists for server %s",
                             MappingUserName(useId),
                             stmt->servername)));
     }
 
     fdw = GetForeignDataWrapper(srv->fdwid);
 
     /*
      * Insert tuple into pg_user_mapping.
      */
     memset(values, 0, sizeof(values));
     memset(nulls, false, sizeof(nulls));
 
     values[Anum_pg_user_mapping_umuser - 1] = ObjectIdGetDatum(useId);
     values[Anum_pg_user_mapping_umserver - 1] = ObjectIdGetDatum(srv->serverid);
 
     /* Add user options */
     useoptions = transformGenericOptions(UserMappingRelationId,
                                          PointerGetDatum(NULL),
                                          stmt->options,
                                          fdw->fdwvalidator);
 
     if (PointerIsValid(DatumGetPointer(useoptions)))
         values[Anum_pg_user_mapping_umoptions - 1] = useoptions;
     else
         nulls[Anum_pg_user_mapping_umoptions - 1] = true;
 
     tuple = heap_form_tuple(rel->rd_att, values, nulls);
 
     umId = CatalogTupleInsert(rel, tuple);
 
     heap_freetuple(tuple);
 
     /* Add dependency on the server */
     myself.classId = UserMappingRelationId;
     myself.objectId = umId;
     myself.objectSubId = 0;
 
     referenced.classId = ForeignServerRelationId;
     referenced.objectId = srv->serverid;
     referenced.objectSubId = 0;
     recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
     if (OidIsValid(useId))
     {
         /* Record the mapped user dependency */
         recordDependencyOnOwner(UserMappingRelationId, umId, useId);
     }
 
     /* dependency on extension */
     recordDependencyOnCurrentExtension(&myself, false);
 
     /* Post creation hook for new user mapping */
     InvokeObjectPostCreateHook(UserMappingRelationId, umId, 0);
 
     heap_close(rel, RowExclusiveLock);
 
     return myself;
 }

Functions

Function Documentation