#include "catalog/objectaddress.h"
#include "nodes/params.h"
#include "parser/parse_node.h"
#include "tcop/dest.h"
#include "utils/array.h"

Include dependency graph for defrem.h:

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

Go to the source code of this file.

Functions
void	RemoveObjects (DropStmt *stmt)

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

void	ExecReindex (ParseState pstate, ReindexStmt stmt, bool isTopLevel)

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 isconstraint)

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

Oid	GetDefaultOpClass (Oid type_id, Oid am_id)

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

ObjectAddress	CreateFunction (ParseState pstate, CreateFunctionStmt stmt)

void	RemoveFunctionById (Oid funcOid)

ObjectAddress	AlterFunction (ParseState pstate, AlterFunctionStmt stmt)

ObjectAddress	CreateCast (CreateCastStmt *stmt)

ObjectAddress	CreateTransform (CreateTransformStmt *stmt)

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

void	ExecuteDoStmt (DoStmt *stmt, bool atomic)

void	ExecuteCallStmt (CallStmt stmt, ParamListInfo params, bool atomic, DestReceiver dest)

TupleDesc	CallStmtResultDesc (CallStmt *stmt)

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

void	interpret_function_parameter_list (ParseState pstate, List parameters, Oid languageOid, ObjectType objtype, 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)

ObjectAddress	AlterStatistics (AlterStatsStmt *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, bool replace)

ObjectAddress	DefineOpClass (CreateOpClassStmt *stmt)

ObjectAddress	DefineOpFamily (CreateOpFamilyStmt *stmt)

Oid	AlterOpFamily (AlterOpFamilyStmt *stmt)

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)

ObjectAddress	DefineTSDictionary (List names, List parameters)

ObjectAddress	AlterTSDictionary (AlterTSDictionaryStmt *stmt)

ObjectAddress	DefineTSTemplate (List names, List parameters)

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)

ObjectAddress	CreateForeignServer (CreateForeignServerStmt *stmt)

ObjectAddress	AlterForeignServer (AlterForeignServerStmt *stmt)

ObjectAddress	CreateUserMapping (CreateUserMappingStmt *stmt)

ObjectAddress	AlterUserMapping (AlterUserMappingStmt *stmt)

Oid	RemoveUserMapping (DropUserMappingStmt *stmt)

void	CreateForeignTable (CreateForeignTableStmt *stmt, Oid relid)

void	ImportForeignSchema (ImportForeignSchemaStmt *stmt)

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

ObjectAddress	CreateAccessMethod (CreateAmStmt *stmt)

Oid	get_index_am_oid (const char *amname, bool missing_ok)

Oid	get_table_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

◆ AlterForeignDataWrapper()

ObjectAddress AlterForeignDataWrapper ( AlterFdwStmt * stmt )

Definition at line 678 of file foreigncmds.c.

References CatalogTupleUpdate(), ObjectAddress::classId, CStringGetDatum, DatumGetPointer, deleteDependencyRecordsForClass(), DEPENDENCY_NORMAL, ereport, errcode(), errhint(), errmsg(), ERROR, AlterFdwStmt::fdwname, FOREIGNDATAWRAPPERNAME, FOREIGNDATAWRAPPEROID, AlterFdwStmt::func_options, GETSTRUCT, heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, AlterFdwStmt::options, parse_func_options(), PointerGetDatum, PointerIsValid, recordDependencyOn(), RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, superuser(), SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), 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 = table_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 = fdwForm->oid;
 
     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);
 
     table_close(rel, RowExclusiveLock);
 
     return myself;
 }

◆ AlterForeignDataWrapperOwner()

ObjectAddress AlterForeignDataWrapperOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 275 of file foreigncmds.c.

References AlterForeignDataWrapperOwner_internal(), CStringGetDatum, ereport, errcode(), errmsg(), ERROR, FOREIGNDATAWRAPPERNAME, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, ObjectAddressSet, RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by ExecAlterOwnerStmt().

 {
     Oid         fdwId;
     HeapTuple   tup;
     Relation    rel;
     ObjectAddress address;
     Form_pg_foreign_data_wrapper form;
 
 
     rel = table_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)));
 
     form = (Form_pg_foreign_data_wrapper) GETSTRUCT(tup);
     fdwId = form->oid;
 
     AlterForeignDataWrapperOwner_internal(rel, tup, newOwnerId);
 
     ObjectAddressSet(address, ForeignDataWrapperRelationId, fdwId);
 
     heap_freetuple(tup);
 
     table_close(rel, RowExclusiveLock);
 
     return address;
 }

◆ AlterForeignDataWrapperOwner_oid()

void AlterForeignDataWrapperOwner_oid	(	Oid	fwdId,
		Oid	newOwnerId
	)

Definition at line 313 of file foreigncmds.c.

References AlterForeignDataWrapperOwner_internal(), ereport, errcode(), errmsg(), ERROR, FOREIGNDATAWRAPPEROID, heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum, RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by shdepReassignOwned().

 {
     HeapTuple   tup;
     Relation    rel;
 
     rel = table_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);
 
     table_close(rel, RowExclusiveLock);
 }

◆ AlterForeignServer()

ObjectAddress AlterForeignServer ( AlterForeignServerStmt * stmt )

Definition at line 969 of file foreigncmds.c.

References aclcheck_error(), ACLCHECK_NOT_OWNER, CatalogTupleUpdate(), CStringGetDatum, CStringGetTextDatum, DatumGetPointer, ereport, errcode(), errmsg(), ERROR, ForeignDataWrapper::fdwvalidator, FOREIGNSERVERNAME, FOREIGNSERVEROID, GetForeignDataWrapper(), GETSTRUCT, GetUserId(), AlterForeignServerStmt::has_version, heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, OBJECT_FOREIGN_SERVER, ObjectAddressSet, AlterForeignServerStmt::options, pg_foreign_server_ownercheck(), PointerGetDatum, PointerIsValid, RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, AlterForeignServerStmt::servername, SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), 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 = table_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)));
 
     srvForm = (Form_pg_foreign_server) GETSTRUCT(tp);
     srvId = srvForm->oid;
 
     /*
      * Only owner or a superuser can ALTER a SERVER.
      */
     if (!pg_foreign_server_ownercheck(srvId, GetUserId()))
         aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_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);
 
     table_close(rel, RowExclusiveLock);
 
     return address;
 }

◆ AlterForeignServerOwner()

ObjectAddress AlterForeignServerOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 415 of file foreigncmds.c.

References AlterForeignServerOwner_internal(), CStringGetDatum, ereport, errcode(), errmsg(), ERROR, FOREIGNSERVERNAME, GETSTRUCT, heap_freetuple(), HeapTupleIsValid, ObjectAddressSet, RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by ExecAlterOwnerStmt().

 {
     Oid         servOid;
     HeapTuple   tup;
     Relation    rel;
     ObjectAddress address;
     Form_pg_foreign_server form;
 
     rel = table_open(ForeignServerRelationId, RowExclusiveLock);
 
     tup = SearchSysCacheCopy1(FOREIGNSERVERNAME, CStringGetDatum(name));
 
     if (!HeapTupleIsValid(tup))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("server \"%s\" does not exist", name)));
 
     form = (Form_pg_foreign_server) GETSTRUCT(tup);
     servOid = form->oid;
 
     AlterForeignServerOwner_internal(rel, tup, newOwnerId);
 
     ObjectAddressSet(address, ForeignServerRelationId, servOid);
 
     heap_freetuple(tup);
 
     table_close(rel, RowExclusiveLock);
 
     return address;
 }

◆ AlterForeignServerOwner_oid()

void AlterForeignServerOwner_oid	(	Oid	,
		Oid	newOwnerId
	)

Definition at line 450 of file foreigncmds.c.

References AlterForeignServerOwner_internal(), ereport, errcode(), errmsg(), ERROR, FOREIGNSERVEROID, heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum, RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by shdepReassignOwned().

 {
     HeapTuple   tup;
     Relation    rel;
 
     rel = table_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);
 
     table_close(rel, RowExclusiveLock);
 }

◆ AlterFunction()

ObjectAddress AlterFunction	(	ParseState *	pstate,
		AlterFunctionStmt *	stmt
	)

Definition at line 1231 of file functioncmds.c.

References aclcheck_error(), ACLCHECK_NOT_OWNER, AlterFunctionStmt::actions, DefElem::arg, CatalogTupleUpdate(), changeDependencyFor(), ObjectAddress::classId, compute_common_attribute(), DatumGetArrayTypeP, defGetNumeric(), DefElem::defname, DEPENDENCY_NORMAL, elog, ereport, errcode(), errmsg(), ERROR, AlterFunctionStmt::func, GETSTRUCT, GetUserId(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, interpret_func_parallel(), interpret_func_support(), interpret_func_volatility(), intVal, InvokeObjectPostAlterHook, lfirst, LookupFuncWithArgs(), NameListToString(), NIL, NoLock, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, ObjectWithArgs::objname, AlterFunctionStmt::objtype, OidIsValid, pg_proc_ownercheck(), PointerGetDatum, PROCOID, recordDependencyOn(), RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, superuser(), SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), and update_proconfig_value().

Referenced by ProcessUtilitySlow().

 {
     HeapTuple   tup;
     Oid         funcOid;
     Form_pg_proc procForm;
     bool        is_procedure;
     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    *support_item = NULL;
     DefElem    *parallel_item = NULL;
     ObjectAddress address;
 
     rel = table_open(ProcedureRelationId, RowExclusiveLock);
 
     funcOid = LookupFuncWithArgs(stmt->objtype, stmt->func, false);
 
     ObjectAddressSet(address, ProcedureRelationId, funcOid);
 
     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, stmt->objtype,
                        NameListToString(stmt->func->objname));
 
     if (procForm->prokind == PROKIND_AGGREGATE)
         ereport(ERROR,
                 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                  errmsg("\"%s\" is an aggregate function",
                         NameListToString(stmt->func->objname))));
 
     is_procedure = (procForm->prokind == PROKIND_PROCEDURE);
 
     /* Examine requested actions. */
     foreach(l, stmt->actions)
     {
         DefElem    *defel = (DefElem *) lfirst(l);
 
         if (compute_common_attribute(pstate,
                                      is_procedure,
                                      defel,
                                      &volatility_item,
                                      &strict_item,
                                      &security_def_item,
                                      &leakproof_item,
                                      &set_items,
                                      &cost_item,
                                      &rows_item,
                                      &support_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 (support_item)
     {
         /* interpret_func_support handles the privilege check */
         Oid         newsupport = interpret_func_support(support_item);
 
         /* Add or replace dependency on support function */
         if (OidIsValid(procForm->prosupport))
             changeDependencyFor(ProcedureRelationId, funcOid,
                                 ProcedureRelationId, procForm->prosupport,
                                 newsupport);
         else
         {
             ObjectAddress referenced;
 
             referenced.classId = ProcedureRelationId;
             referenced.objectId = newsupport;
             referenced.objectSubId = 0;
             recordDependencyOn(&address, &referenced, DEPENDENCY_NORMAL);
         }
 
         procForm->prosupport = newsupport;
     }
     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);
 
     table_close(rel, NoLock);
     heap_freetuple(tup);
 
     return address;
 }

◆ AlterOperator()

ObjectAddress AlterOperator ( AlterOperatorStmt * stmt )

Definition at line 409 of file operatorcmds.c.

References aclcheck_error(), ACLCHECK_NOT_OWNER, DefElem::arg, CatalogTupleUpdate(), defGetQualifiedName(), DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, GETSTRUCT, GetUserId(), heap_modify_tuple(), HeapTupleIsValid, i, InvalidOid, InvokeObjectPostAlterHook, lfirst, LookupOperWithArgs(), makeOperatorDependencies(), NameStr, NIL, NoLock, OBJECT_OPERATOR, ObjectIdGetDatum, OidIsValid, AlterOperatorStmt::opername, OPEROID, AlterOperatorStmt::options, pg_oper_ownercheck(), RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), table_open(), 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. function */
     bool        updateRestriction = false;
     Oid         restrictionOid;
     List       *joinName = NIL; /* optional join sel. function */
     bool        updateJoin = false;
     Oid         joinOid;
 
     /* Look up the operator */
     oprId = LookupOperWithArgs(stmt->opername, false);
     catalog = table_open(OperatorRelationId, RowExclusiveLock);
     tup = SearchSysCacheCopy1(OPEROID, ObjectIdGetDatum(oprId));
     if (!HeapTupleIsValid(tup))
         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 (strcmp(defel->defname, "restrict") == 0)
         {
             restrictionName = param;
             updateRestriction = true;
         }
         else if (strcmp(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 (strcmp(defel->defname, "leftarg") == 0 ||
                  strcmp(defel->defname, "rightarg") == 0 ||
                  strcmp(defel->defname, "function") == 0 ||
                  strcmp(defel->defname, "procedure") == 0 ||
                  strcmp(defel->defname, "commutator") == 0 ||
                  strcmp(defel->defname, "negator") == 0 ||
                  strcmp(defel->defname, "hashes") == 0 ||
                  strcmp(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, OBJECT_OPERATOR,
                        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);
 
     table_close(catalog, NoLock);
 
     return address;
 }

◆ AlterOpFamily()

Oid AlterOpFamily ( AlterOpFamilyStmt * stmt )

Definition at line 808 of file opclasscmds.c.

References AlterOpFamilyAdd(), AlterOpFamilyDrop(), AMNAME, AlterOpFamilyStmt::amname, IndexAmRoutine::amoptsprocnum, IndexAmRoutine::amstrategies, IndexAmRoutine::amsupport, CStringGetDatum, ereport, errcode(), errmsg(), ERROR, get_opfamily_oid(), GetIndexAmRoutineByAmId(), GETSTRUCT, 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 */
                 optsProcNumber, /* amopclassopts value */
                 maxProcNumber;  /* amsupport value */
     HeapTuple   tup;
     Form_pg_am  amform;
     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)));
 
     amform = (Form_pg_am) GETSTRUCT(tup);
     amoid = amform->oid;
     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;
     optsProcNumber = amroutine->amoptsprocnum;
 
     /* 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, optsProcNumber,
                          stmt->items);
 
     return opfamilyoid;
 }

◆ AlterStatistics()

ObjectAddress AlterStatistics ( AlterStatsStmt * stmt )

Definition at line 434 of file statscmds.c.

References aclcheck_error(), ACLCHECK_NOT_OWNER, Assert, CatalogTupleUpdate(), DeconstructQualifiedName(), AlterStatsStmt::defnames, ereport, errcode(), errmsg(), ERROR, get_statistics_object_oid(), GetUserId(), heap_freetuple(), heap_modify_tuple(), Int32GetDatum, InvalidObjectAddress, InvokeObjectPostAlterHook, AlterStatsStmt::missing_ok, NameListToString(), NOTICE, OBJECT_STATISTIC_EXT, ObjectAddressSet, ObjectIdGetDatum, OidIsValid, pg_statistics_object_ownercheck(), RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), STATEXTOID, AlterStatsStmt::stxstattarget, HeapTupleData::t_self, table_close(), table_open(), and WARNING.

Referenced by ProcessUtilitySlow().

 {
     Relation    rel;
     Oid         stxoid;
     HeapTuple   oldtup;
     HeapTuple   newtup;
     Datum       repl_val[Natts_pg_statistic_ext];
     bool        repl_null[Natts_pg_statistic_ext];
     bool        repl_repl[Natts_pg_statistic_ext];
     ObjectAddress address;
     int         newtarget = stmt->stxstattarget;
 
     /* Limit statistics target to a sane range */
     if (newtarget < -1)
     {
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("statistics target %d is too low",
                         newtarget)));
     }
     else if (newtarget > 10000)
     {
         newtarget = 10000;
         ereport(WARNING,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("lowering statistics target to %d",
                         newtarget)));
     }
 
     /* lookup OID of the statistics object */
     stxoid = get_statistics_object_oid(stmt->defnames, stmt->missing_ok);
 
     /*
      * If we got here and the OID is not valid, it means the statistics does
      * not exist, but the command specified IF EXISTS. So report this as a
      * simple NOTICE and we're done.
      */
     if (!OidIsValid(stxoid))
     {
         char       *schemaname;
         char       *statname;
 
         Assert(stmt->missing_ok);
 
         DeconstructQualifiedName(stmt->defnames, &schemaname, &statname);
 
         if (schemaname)
             ereport(NOTICE,
                     (errmsg("statistics object \"%s.%s\" does not exist, skipping",
                             schemaname, statname)));
         else
             ereport(NOTICE,
                     (errmsg("statistics object \"%s\" does not exist, skipping",
                             statname)));
 
         return InvalidObjectAddress;
     }
 
     /* Search pg_statistic_ext */
     rel = table_open(StatisticExtRelationId, RowExclusiveLock);
 
     oldtup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(stxoid));
 
     /* Must be owner of the existing statistics object */
     if (!pg_statistics_object_ownercheck(stxoid, GetUserId()))
         aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_STATISTIC_EXT,
                        NameListToString(stmt->defnames));
 
     /* Build new tuple. */
     memset(repl_val, 0, sizeof(repl_val));
     memset(repl_null, false, sizeof(repl_null));
     memset(repl_repl, false, sizeof(repl_repl));
 
     /* replace the stxstattarget column */
     repl_repl[Anum_pg_statistic_ext_stxstattarget - 1] = true;
     repl_val[Anum_pg_statistic_ext_stxstattarget - 1] = Int32GetDatum(newtarget);
 
     newtup = heap_modify_tuple(oldtup, RelationGetDescr(rel),
                                repl_val, repl_null, repl_repl);
 
     /* Update system catalog. */
     CatalogTupleUpdate(rel, &newtup->t_self, newtup);
 
     InvokeObjectPostAlterHook(StatisticExtRelationId, stxoid, 0);
 
     ObjectAddressSet(address, StatisticExtRelationId, stxoid);
 
     /*
      * NOTE: because we only support altering the statistics target, not the
      * other fields, there is no need to update dependencies.
      */
 
     heap_freetuple(newtup);
     ReleaseSysCache(oldtup);
 
     table_close(rel, RowExclusiveLock);
 
     return address;
 }

◆ AlterTSConfiguration()

ObjectAddress AlterTSConfiguration ( AlterTSConfigurationStmt * stmt )

Definition at line 1109 of file tsearchcmds.c.

References aclcheck_error(), ACLCHECK_NOT_OWNER, AlterTSConfigurationStmt::cfgname, AlterTSConfigurationStmt::dicts, DropConfigurationMapping(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, GetTSConfigTuple(), GetUserId(), HeapTupleIsValid, InvokeObjectPostAlterHook, makeConfigurationDependencies(), MakeConfigurationMapping(), NameListToString(), OBJECT_TSCONFIGURATION, ObjectAddressSet, pg_ts_config_ownercheck(), ReleaseSysCache(), RowExclusiveLock, table_close(), table_open(), and AlterTSConfigurationStmt::tokentype.

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 = ((Form_pg_ts_config) GETSTRUCT(tup))->oid;
 
     /* must be owner */
     if (!pg_ts_config_ownercheck(cfgId, GetUserId()))
         aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_TSCONFIGURATION,
                        NameListToString(stmt->cfgname));
 
     relMap = table_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, cfgId, 0);
 
     ObjectAddressSet(address, TSConfigRelationId, cfgId);
 
     table_close(relMap, RowExclusiveLock);
 
     ReleaseSysCache(tup);
 
     return address;
 }

◆ AlterTSDictionary()

ObjectAddress AlterTSDictionary ( AlterTSDictionaryStmt * stmt )

Definition at line 487 of file tsearchcmds.c.

References aclcheck_error(), ACLCHECK_NOT_OWNER, DefElem::arg, CatalogTupleUpdate(), DefElem::defname, deserialize_deflist(), AlterTSDictionaryStmt::dictname, elog, ERROR, foreach_delete_current, get_ts_dict_oid(), GETSTRUCT, GetUserId(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, lappend(), lfirst, NameListToString(), NIL, OBJECT_TSDICTIONARY, ObjectAddressSet, ObjectIdGetDatum, AlterTSDictionaryStmt::options, pg_ts_dict_ownercheck(), PointerGetDatum, RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), serialize_deflist(), SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), 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 = table_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, OBJECT_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;
 
         /*
          * Remove any matches ...
          */
         foreach(cell, dictoptions)
         {
             DefElem    *oldel = (DefElem *) lfirst(cell);
 
             if (strcmp(oldel->defname, defel->defname) == 0)
                 dictoptions = foreach_delete_current(dictoptions, 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);
 
     table_close(rel, RowExclusiveLock);
 
     return address;
 }

◆ AlterUserMapping()

ObjectAddress AlterUserMapping ( AlterUserMappingStmt * stmt )

Definition at line 1217 of file foreigncmds.c.

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

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 = table_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, Anum_pg_user_mapping_oid,
                            ObjectIdGetDatum(useId),
                            ObjectIdGetDatum(srv->serverid));
     if (!OidIsValid(umId))
         ereport(ERROR,
                 (errcode(ERRCODE_UNDEFINED_OBJECT),
                  errmsg("user mapping for \"%s\" does not exist for server \"%s\"",
                         MappingUserName(useId), stmt->servername)));
 
     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);
 
     InvokeObjectPostAlterHook(UserMappingRelationId,
                               umId, 0);
 
     ObjectAddressSet(address, UserMappingRelationId, umId);
 
     heap_freetuple(tp);
 
     table_close(rel, RowExclusiveLock);
 
     return address;
 }

◆ CallStmtResultDesc()

TupleDesc CallStmtResultDesc ( CallStmt * stmt )

Definition at line 2239 of file functioncmds.c.

References build_function_result_tupdesc_t(), elog, ERROR, CallStmt::funcexpr, FuncExpr::funcid, HeapTupleIsValid, ObjectIdGetDatum, PROCOID, ReleaseSysCache(), and SearchSysCache1().

Referenced by UtilityTupleDescriptor().

 {
     FuncExpr   *fexpr;
     HeapTuple   tuple;
     TupleDesc   tupdesc;
 
     fexpr = stmt->funcexpr;
 
     tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(fexpr->funcid));
     if (!HeapTupleIsValid(tuple))
         elog(ERROR, "cache lookup failed for procedure %u", fexpr->funcid);
 
     tupdesc = build_function_result_tupdesc_t(tuple);
 
     ReleaseSysCache(tuple);
 
     return tupdesc;
 }

◆ CheckIndexCompatible()

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

Definition at line 164 of file indexcmds.c.

References AccessShareLock, IndexAmRoutine::amcanorder, AMNAME, Assert, CompareOpclassOptions(), ComputeIndexAttrs(), DatumGetPointer, elog, ereport, errcode(), errmsg(), ERROR, get_opclass_input_type(), GetIndexAmRoutine(), GETSTRUCT, heap_attisnull(), HeapTupleIsValid, i, IndexInfo::ii_ExclusionOps, IndexInfo::ii_OpclassOptions, index_close(), INDEX_MAX_KEYS, index_open(), IndexGetRelation(), INDEXRELID, list_length(), makeIndexInfo(), NIL, NoLock, ObjectIdGetDatum, op_input_types(), palloc(), pfree(), PointerGetDatum, RelationData::rd_att, RelationGetExclusionInfo(), RelationGetIndexRawAttOptions(), 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)));
     accessMethodForm = (Form_pg_am) GETSTRUCT(tuple);
     accessMethodId = accessMethodForm->oid;
     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.  Our attributeList
      * contains only key attributes, thus we're filling ii_NumIndexAttrs and
      * ii_NumIndexKeyAttrs with same value.
      */
     indexInfo = makeIndexInfo(numberOfAttributes, numberOfAttributes,
                               accessMethodId, NIL, NIL, false, false, false);
     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, NULL) &&
           heap_attisnull(tuple, Anum_pg_index_indexprs, NULL) &&
           indexForm->indisvalid))
     {
         ReleaseSysCache(tuple);
         return false;
     }
 
     /* Any change in operator class or collation breaks compatibility. */
     old_natts = indexForm->indnkeyatts;
     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 opclass options break compatibility. */
     if (ret)
     {
         Datum      *opclassOptions = RelationGetIndexRawAttOptions(irel);
 
         ret = CompareOpclassOptions(opclassOptions,
                                     indexInfo->ii_OpclassOptions, old_natts);
 
         if (opclassOptions)
             pfree(opclassOptions);
     }
 
     /* 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;
 }

◆ ChooseRelationName()

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

Definition at line 2294 of file indexcmds.c.

References ConstraintNameExists(), get_relname_relid(), makeObjectName(), NAMEDATALEN, OidIsValid, pfree(), relname, snprintf, and strlcpy().

Referenced by ChooseIndexName(), generateSerialExtraStmts(), and ReindexRelationConcurrently().

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

◆ CreateAccessMethod()

ObjectAddress CreateAccessMethod ( CreateAmStmt * stmt )

Definition at line 43 of file amcmds.c.

References AMNAME, CreateAmStmt::amname, AmOidIndexId, CreateAmStmt::amtype, CatalogTupleInsert(), CharGetDatum, ObjectAddress::classId, CStringGetDatum, DEPENDENCY_NORMAL, DirectFunctionCall1, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errhint(), errmsg(), ERROR, GetNewOidWithIndex(), GetSysCacheOid1, CreateAmStmt::handler_name, heap_form_tuple(), heap_freetuple(), InvokeObjectPostCreateHook, lookup_am_handler_func(), namein(), ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, recordDependencyOn(), recordDependencyOnCurrentExtension(), RelationGetDescr, RowExclusiveLock, superuser(), table_close(), table_open(), 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 = table_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, Anum_pg_am_oid,
                             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_am_handler_func(stmt->handler_name, stmt->amtype);
 
     /*
      * Insert tuple into pg_am.
      */
     memset(values, 0, sizeof(values));
     memset(nulls, false, sizeof(nulls));
 
     amoid = GetNewOidWithIndex(rel, AmOidIndexId, Anum_pg_am_oid);
     values[Anum_pg_am_oid - 1] = ObjectIdGetDatum(amoid);
     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);
 
     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);
 
     InvokeObjectPostCreateHook(AccessMethodRelationId, amoid, 0);
 
     table_close(rel, RowExclusiveLock);
 
     return myself;
 }

◆ CreateCast()

ObjectAddress CreateCast ( CreateCastStmt * stmt )

Definition at line 1404 of file functioncmds.c.

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, CastCreate(), COERCION_ASSIGNMENT, COERCION_EXPLICIT, COERCION_IMPLICIT, CreateCastStmt::context, DEPENDENCY_NORMAL, elog, ereport, errcode(), errmsg(), ERROR, format_type_be(), CreateCastStmt::func, get_element_type(), get_typlenbyvalalign(), get_typtype(), GETSTRUCT, GetUserId(), HeapTupleIsValid, CreateCastStmt::inout, InvalidOid, IsBinaryCoercible(), LookupFuncWithArgs(), OBJECT_FUNCTION, ObjectIdGetDatum, OidIsValid, pg_type_aclcheck(), pg_type_ownercheck(), PROCOID, ReleaseSysCache(), SearchSysCache1(), CreateCastStmt::sourcetype, superuser(), CreateCastStmt::targettype, TypeNameToString(), typenameTypeId(), and WARNING.

Referenced by ProcessUtilitySlow().

 {
     Oid         sourcetypeid;
     Oid         targettypeid;
     char        sourcetyptype;
     char        targettyptype;
     Oid         funcid;
     int         nargs;
     char        castcontext;
     char        castmethod;
     HeapTuple   tuple;
     AclResult   aclresult;
     ObjectAddress myself;
 
     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(OBJECT_FUNCTION, 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->prokind != PROKIND_FUNCTION)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("cast function must be a normal 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;
             /* COERCION_PLPGSQL is intentionally not covered here */
         case COERCION_EXPLICIT:
             castcontext = COERCION_CODE_EXPLICIT;
             break;
         default:
             elog(ERROR, "unrecognized CoercionContext: %d", stmt->context);
             castcontext = 0;    /* keep compiler quiet */
             break;
     }
 
     myself = CastCreate(sourcetypeid, targettypeid, funcid, castcontext,
                         castmethod, DEPENDENCY_NORMAL);
     return myself;
 }

◆ CreateForeignDataWrapper()

ObjectAddress CreateForeignDataWrapper ( CreateFdwStmt * stmt )

Definition at line 562 of file foreigncmds.c.

References CatalogTupleInsert(), ObjectAddress::classId, CStringGetDatum, DatumGetPointer, DEPENDENCY_NORMAL, DirectFunctionCall1, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errhint(), errmsg(), ERROR, CreateFdwStmt::fdwname, ForeignDataWrapperOidIndexId, CreateFdwStmt::func_options, GetForeignDataWrapperByName(), GetNewOidWithIndex(), GetUserId(), heap_form_tuple(), heap_freetuple(), InvokeObjectPostCreateHook, namein(), ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, CreateFdwStmt::options, parse_func_options(), PointerGetDatum, PointerIsValid, RelationData::rd_att, recordDependencyOn(), recordDependencyOnCurrentExtension(), recordDependencyOnOwner(), RowExclusiveLock, superuser(), table_close(), table_open(), 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 = table_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));
 
     fdwId = GetNewOidWithIndex(rel, ForeignDataWrapperOidIndexId,
                                Anum_pg_foreign_data_wrapper_oid);
     values[Anum_pg_foreign_data_wrapper_oid - 1] = ObjectIdGetDatum(fdwId);
     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);
 
     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);
 
     table_close(rel, RowExclusiveLock);
 
     return myself;
 }

◆ CreateForeignServer()

ObjectAddress CreateForeignServer ( CreateForeignServerStmt * stmt )

Definition at line 842 of file foreigncmds.c.

References ACL_USAGE, aclcheck_error(), ACLCHECK_OK, CatalogTupleInsert(), ObjectAddress::classId, CStringGetDatum, CStringGetTextDatum, DatumGetPointer, DEPENDENCY_NORMAL, DirectFunctionCall1, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, ForeignDataWrapper::fdwid, ForeignDataWrapper::fdwname, CreateForeignServerStmt::fdwname, ForeignDataWrapper::fdwvalidator, ForeignServerOidIndexId, GetForeignDataWrapperByName(), GetForeignServerByName(), GetNewOidWithIndex(), GetUserId(), heap_form_tuple(), heap_freetuple(), CreateForeignServerStmt::if_not_exists, InvalidObjectAddress, InvokeObjectPostCreateHook, namein(), NOTICE, OBJECT_FDW, 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, table_close(), table_open(), 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 = table_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)));
             table_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, OBJECT_FDW, fdw->fdwname);
 
     /*
      * Insert tuple into pg_foreign_server.
      */
     memset(values, 0, sizeof(values));
     memset(nulls, false, sizeof(nulls));
 
     srvId = GetNewOidWithIndex(rel, ForeignServerOidIndexId,
                                Anum_pg_foreign_server_oid);
     values[Anum_pg_foreign_server_oid - 1] = ObjectIdGetDatum(srvId);
     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);
 
     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);
 
     table_close(rel, RowExclusiveLock);
 
     return myself;
 }

◆ CreateForeignTable()

void CreateForeignTable	(	CreateForeignTableStmt *	stmt,
		Oid	relid
	)

Definition at line 1395 of file foreigncmds.c.

References ACL_USAGE, aclcheck_error(), ACLCHECK_OK, CatalogTupleInsert(), ObjectAddress::classId, CommandCounterIncrement(), DatumGetPointer, DEPENDENCY_NORMAL, ForeignServer::fdwid, ForeignDataWrapper::fdwvalidator, GetForeignDataWrapper(), GetForeignServerByName(), GetUserId(), heap_form_tuple(), heap_freetuple(), OBJECT_FOREIGN_SERVER, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, CreateForeignTableStmt::options, pg_foreign_server_aclcheck(), PointerGetDatum, PointerIsValid, RelationData::rd_att, recordDependencyOn(), RowExclusiveLock, ForeignServer::serverid, ForeignServer::servername, CreateForeignTableStmt::servername, table_close(), table_open(), 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 = table_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, OBJECT_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);
 
     table_close(ftrel, RowExclusiveLock);
 }

◆ CreateFunction()

ObjectAddress CreateFunction	(	ParseState *	pstate,
		CreateFunctionStmt *	stmt
	)

Definition at line 918 of file functioncmds.c.

References ACL_CREATE, ACL_USAGE, aclcheck_error(), ACLCHECK_NO_PRIV, ACLCHECK_OK, Assert, castNode, compute_function_attributes(), compute_return_type(), construct_array(), ereport, errcode(), errhint(), errmsg(), ERROR, extension_file_exists(), format_type_be(), CreateFunctionStmt::funcname, get_base_element_type(), get_namespace_name(), get_transform_oid(), GETSTRUCT, GetUserId(), HeapTupleIsValid, i, interpret_AS_clause(), interpret_function_parameter_list(), InvalidOid, CreateFunctionStmt::is_procedure, LANGNAME, lappend_oid(), lfirst_node, lfirst_oid, list_length(), NameStr, NIL, OBJECT_FUNCTION, OBJECT_LANGUAGE, OBJECT_PROCEDURE, OBJECT_SCHEMA, ObjectIdGetDatum, OidIsValid, CreateFunctionStmt::options, palloc(), CreateFunctionStmt::parameters, pg_language_aclcheck(), pg_namespace_aclcheck(), PointerGetDatum, ProcedureCreate(), QualifiedNameGetCreationNamespace(), ReleaseSysCache(), CreateFunctionStmt::replace, CreateFunctionStmt::returnType, SearchSysCache1(), superuser(), and typenameTypeId().

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;
     Oid         prosupport;
     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, OBJECT_SCHEMA,
                        get_namespace_name(namespaceId));
 
     /* Set 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 */
     prosupport = InvalidOid;
     parallel = PROPARALLEL_UNSAFE;
 
     /* Extract non-default attributes from stmt->options list */
     compute_function_attributes(pstate,
                                 stmt->is_procedure,
                                 stmt->options,
                                 &as_clause, &language, &transformDefElem,
                                 &isWindowFunc, &volatility,
                                 &isStrict, &security, &isLeakProof,
                                 &proconfig, &procost, &prorows,
                                 &prosupport, &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),
                  (extension_file_exists(language) ?
                   errhint("Use CREATE EXTENSION to load the language into the database.") : 0)));
 
     languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
     languageOid = languageStruct->oid;
 
     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, OBJECT_LANGUAGE,
                            NameStr(languageStruct->lanname));
     }
     else
     {
         /* if untrusted language, must be superuser */
         if (!superuser())
             aclcheck_error(ACLCHECK_NO_PRIV, OBJECT_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,
                                       stmt->is_procedure ? OBJECT_PROCEDURE : OBJECT_FUNCTION,
                                       &parameterTypes,
                                       &allParameterTypes,
                                       &parameterModes,
                                       &parameterNames,
                                       &parameterDefaults,
                                       &variadicArgType,
                                       &requiredResultType);
 
     if (stmt->is_procedure)
     {
         Assert(!stmt->returnType);
         prorettype = requiredResultType ? requiredResultType : VOIDOID;
         returnsSet = false;
     }
     else 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, TYPALIGN_INT);
     }
     else
     {
         /* store SQL NULL instead of empty array */
         trftypes = NULL;
     }
 
     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 */
                            stmt->is_procedure ? PROKIND_PROCEDURE : (isWindowFunc ? PROKIND_WINDOW : PROKIND_FUNCTION),
                            security,
                            isLeakProof,
                            isStrict,
                            volatility,
                            parallel,
                            parameterTypes,
                            PointerGetDatum(allParameterTypes),
                            PointerGetDatum(parameterModes),
                            PointerGetDatum(parameterNames),
                            parameterDefaults,
                            PointerGetDatum(trftypes),
                            PointerGetDatum(proconfig),
                            prosupport,
                            procost,
                            prorows);
 }

◆ CreateStatistics()

ObjectAddress CreateStatistics ( CreateStatsStmt * stmt )

Definition at line 62 of file statscmds.c.

References aclcheck_error(), ACLCHECK_NOT_OWNER, allowSystemTableMods, Assert, attname, buildint2vector(), CacheInvalidateRelcache(), CatalogTupleInsert(), CharGetDatum, ChooseExtendedStatisticName(), ChooseExtendedStatisticNameAddition(), compare_int16(), construct_array(), CreateComments(), CStringGetDatum, CreateStatsStmt::defnames, DEPENDENCY_AUTO, DEPENDENCY_NORMAL, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, CreateStatsStmt::exprs, ColumnRef::fields, format_type_be(), get_relkind_objtype(), GetNewOidWithIndex(), GETSTRUCT, GetUserId(), heap_form_tuple(), heap_freetuple(), HeapTupleIsValid, i, CreateStatsStmt::if_not_exists, Int32GetDatum, InvalidObjectAddress, InvalidOid, InvokeObjectPostCreateHook, IsA, IsSystemRelation(), lengthof, lfirst, linitial, list_length(), lookup_type_cache(), TypeCacheEntry::lt_opr, NameGetDatum, namestrcpy(), NoLock, NOTICE, ObjectAddressSet, ObjectAddressSubSet, ObjectIdGetDatum, pg_class_ownercheck(), PointerGetDatum, qsort, QualifiedNameGetCreationNamespace(), RelationData::rd_att, RelationData::rd_rel, recordDependencyOn(), recordDependencyOnOwner(), relation_close(), relation_openrv(), RelationGetNamespace, RelationGetRelationName, RelationGetRelid, CreateStatsStmt::relations, ReleaseSysCache(), RowExclusiveLock, SearchSysCacheAttName(), SearchSysCacheExists2, ShareUpdateExclusiveLock, CreateStatsStmt::stat_types, STATEXTNAMENSP, StatisticExtOidIndexId, STATS_MAX_DIMENSIONS, strVal, CreateStatsStmt::stxcomment, table_open(), generate_unaccent_rules::type, TYPECACHE_LT_OPR, types, and values.

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];
     Datum       datavalues[Natts_pg_statistic_ext_data];
     bool        datanulls[Natts_pg_statistic_ext_data];
     int2vector *stxkeys;
     Relation    statrel;
     Relation    datarel;
     Relation    rel = NULL;
     Oid         relid;
     ObjectAddress parentobject,
                 myself;
     Datum       types[3];       /* one for each possible type of statistic */
     int         ntypes;
     ArrayType  *stxkind;
     bool        build_ndistinct;
     bool        build_dependencies;
     bool        build_mcv;
     bool        requested_type = false;
     int         i;
     ListCell   *cell;
 
     Assert(IsA(stmt, CreateStatsStmt));
 
     /*
      * 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, get_relkind_objtype(rel->rd_rel->relkind),
                            RelationGetRelationName(rel));
 
         /* Creating statistics on system catalogs is not allowed */
         if (!allowSystemTableMods && IsSystemRelation(rel))
             ereport(ERROR,
                     (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                      errmsg("permission denied: \"%s\" is a system catalog",
                             RelationGetRelationName(rel))));
     }
 
     Assert(rel);
     relid = RelationGetRelid(rel);
 
     /*
      * If the node has a name, split it up and determine creation namespace.
      * If not (a possibility not considered by the grammar, but one which can
      * occur via the "CREATE TABLE ... (LIKE)" command), then we put the
      * object in the same namespace as the relation, and cons up a name for
      * it.
      */
     if (stmt->defnames)
         namespaceId = QualifiedNameGetCreationNamespace(stmt->defnames,
                                                         &namestr);
     else
     {
         namespaceId = RelationGetNamespace(rel);
         namestr = ChooseExtendedStatisticName(RelationGetRelationName(rel),
                                               ChooseExtendedStatisticNameAddition(stmt->exprs),
                                               "stat",
                                               namespaceId);
     }
     namestrcpy(&stxname, namestr);
 
     /*
      * Deal with the possibility that the statistics object already exists.
      */
     if (SearchSysCacheExists2(STATEXTNAMENSP,
                               CStringGetDatum(namestr),
                               ObjectIdGetDatum(namespaceId)))
     {
         if (stmt->if_not_exists)
         {
             ereport(NOTICE,
                     (errcode(ERRCODE_DUPLICATE_OBJECT),
                      errmsg("statistics object \"%s\" already exists, skipping",
                             namestr)));
             relation_close(rel, NoLock);
             return InvalidObjectAddress;
         }
 
         ereport(ERROR,
                 (errcode(ERRCODE_DUPLICATE_OBJECT),
                  errmsg("statistics object \"%s\" already exists", namestr)));
     }
 
     /*
      * 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;
     build_mcv = 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 if (strcmp(type, "mcv") == 0)
         {
             build_mcv = 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;
         build_mcv = 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);
     if (build_mcv)
         types[ntypes++] = CharGetDatum(STATS_EXT_MCV);
     Assert(ntypes > 0 && ntypes <= lengthof(types));
     stxkind = construct_array(types, ntypes, CHAROID, 1, true, TYPALIGN_CHAR);
 
     statrel = table_open(StatisticExtRelationId, RowExclusiveLock);
 
     /*
      * Everything seems fine, so let's build the pg_statistic_ext tuple.
      */
     memset(values, 0, sizeof(values));
     memset(nulls, false, sizeof(nulls));
 
     statoid = GetNewOidWithIndex(statrel, StatisticExtOidIndexId,
                                  Anum_pg_statistic_ext_oid);
     values[Anum_pg_statistic_ext_oid - 1] = ObjectIdGetDatum(statoid);
     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_stxstattarget - 1] = Int32GetDatum(-1);
     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);
 
     /* insert it into pg_statistic_ext */
     htup = heap_form_tuple(statrel->rd_att, values, nulls);
     CatalogTupleInsert(statrel, htup);
     heap_freetuple(htup);
 
     relation_close(statrel, RowExclusiveLock);
 
     /*
      * Also build the pg_statistic_ext_data tuple, to hold the actual
      * statistics data.
      */
     datarel = table_open(StatisticExtDataRelationId, RowExclusiveLock);
 
     memset(datavalues, 0, sizeof(datavalues));
     memset(datanulls, false, sizeof(datanulls));
 
     datavalues[Anum_pg_statistic_ext_data_stxoid - 1] = ObjectIdGetDatum(statoid);
 
     /* no statistics built yet */
     datanulls[Anum_pg_statistic_ext_data_stxdndistinct - 1] = true;
     datanulls[Anum_pg_statistic_ext_data_stxddependencies - 1] = true;
     datanulls[Anum_pg_statistic_ext_data_stxdmcv - 1] = true;
 
     /* insert it into pg_statistic_ext_data */
     htup = heap_form_tuple(datarel->rd_att, datavalues, datanulls);
     CatalogTupleInsert(datarel, htup);
     heap_freetuple(htup);
 
     relation_close(datarel, RowExclusiveLock);
 
     InvokeObjectPostCreateHook(StatisticExtRelationId, statoid, 0);
 
     /*
      * 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.
      */
 
     /* Add any requested comment */
     if (stmt->stxcomment != NULL)
         CreateComments(statoid, StatisticExtRelationId, 0,
                        stmt->stxcomment);
 
     /* Return stats object's address */
     return myself;
 }

◆ CreateTransform()

ObjectAddress CreateTransform ( CreateTransformStmt * stmt )

Definition at line 1678 of file functioncmds.c.

References ACL_EXECUTE, ACL_USAGE, aclcheck_error(), aclcheck_error_type(), ACLCHECK_NOT_OWNER, ACLCHECK_OK, add_exact_object_address(), CatalogTupleInsert(), CatalogTupleUpdate(), check_transform_function(), deleteDependencyRecordsFor(), DEPENDENCY_NORMAL, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, format_type_be(), free_object_addresses(), CreateTransformStmt::fromsql, get_language_oid(), get_typtype(), GetNewOidWithIndex(), GETSTRUCT, GetUserId(), heap_form_tuple(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostCreateHook, CreateTransformStmt::lang, LookupFuncWithArgs(), MemSet, NameListToString(), new_object_addresses(), OBJECT_FUNCTION, OBJECT_LANGUAGE, ObjectAddressSet, ObjectIdGetDatum, ObjectWithArgs::objname, OidIsValid, pg_language_aclcheck(), pg_proc_aclcheck(), pg_proc_ownercheck(), pg_type_aclcheck(), pg_type_ownercheck(), PROCOID, record_object_address_dependencies(), recordDependencyOnCurrentExtension(), RelationGetDescr, ReleaseSysCache(), CreateTransformStmt::replace, RowExclusiveLock, SearchSysCache1(), SearchSysCache2(), HeapTupleData::t_self, table_close(), table_open(), CreateTransformStmt::tosql, TransformOidIndexId, TRFTYPELANG, CreateTransformStmt::type_name, TypeNameToString(), typenameTypeId(), 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;
     ObjectAddresses *addrs;
     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, OBJECT_LANGUAGE, stmt->lang);
 
     /*
      * Get the functions
      */
     if (stmt->fromsql)
     {
         fromsqlfuncid = LookupFuncWithArgs(OBJECT_FUNCTION, stmt->fromsql, false);
 
         if (!pg_proc_ownercheck(fromsqlfuncid, GetUserId()))
             aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, NameListToString(stmt->fromsql->objname));
 
         aclresult = pg_proc_aclcheck(fromsqlfuncid, GetUserId(), ACL_EXECUTE);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, OBJECT_FUNCTION, 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(OBJECT_FUNCTION, stmt->tosql, false);
 
         if (!pg_proc_ownercheck(tosqlfuncid, GetUserId()))
             aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, NameListToString(stmt->tosql->objname));
 
         aclresult = pg_proc_aclcheck(tosqlfuncid, GetUserId(), ACL_EXECUTE);
         if (aclresult != ACLCHECK_OK)
             aclcheck_error(aclresult, OBJECT_FUNCTION, 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 = table_open(TransformRelationId, RowExclusiveLock);
 
     tuple = SearchSysCache2(TRFTYPELANG,
                             ObjectIdGetDatum(typeid),
                             ObjectIdGetDatum(langid));
     if (HeapTupleIsValid(tuple))
     {
         Form_pg_transform form = (Form_pg_transform) GETSTRUCT(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 = form->oid;
         ReleaseSysCache(tuple);
         is_replace = true;
     }
     else
     {
         transformid = GetNewOidWithIndex(relation, TransformOidIndexId,
                                          Anum_pg_transform_oid);
         values[Anum_pg_transform_oid - 1] = ObjectIdGetDatum(transformid);
         newtuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
         CatalogTupleInsert(relation, newtuple);
         is_replace = false;
     }
 
     if (is_replace)
         deleteDependencyRecordsFor(TransformRelationId, transformid, true);
 
     addrs = new_object_addresses();
 
     /* make dependency entries */
     ObjectAddressSet(myself, TransformRelationId, transformid);
 
     /* dependency on language */
     ObjectAddressSet(referenced, LanguageRelationId, langid);
     add_exact_object_address(&referenced, addrs);
 
     /* dependency on type */
     ObjectAddressSet(referenced, TypeRelationId, typeid);
     add_exact_object_address(&referenced, addrs);
 
     /* dependencies on functions */
     if (OidIsValid(fromsqlfuncid))
     {
         ObjectAddressSet(referenced, ProcedureRelationId, fromsqlfuncid);
         add_exact_object_address(&referenced, addrs);
     }
     if (OidIsValid(tosqlfuncid))
     {
         ObjectAddressSet(referenced, ProcedureRelationId, tosqlfuncid);
         add_exact_object_address(&referenced, addrs);
     }
 
     record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
     free_object_addresses(addrs);
 
     /* dependency on extension */
     recordDependencyOnCurrentExtension(&myself, is_replace);
 
     /* Post creation hook for new transform */
     InvokeObjectPostCreateHook(TransformRelationId, transformid, 0);
 
     heap_freetuple(newtuple);
 
     table_close(relation, RowExclusiveLock);
 
     return myself;
 }

◆ CreateUserMapping()

ObjectAddress CreateUserMapping ( CreateUserMappingStmt * stmt )

Definition at line 1095 of file foreigncmds.c.

References ACL_ID_PUBLIC, CatalogTupleInsert(), ObjectAddress::classId, DatumGetPointer, DEPENDENCY_NORMAL, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, ForeignServer::fdwid, ForeignDataWrapper::fdwvalidator, get_rolespec_oid(), GetForeignDataWrapper(), GetForeignServerByName(), GetNewOidWithIndex(), GetSysCacheOid2, heap_form_tuple(), heap_freetuple(), CreateUserMappingStmt::if_not_exists, InvalidObjectAddress, InvokeObjectPostCreateHook, MappingUserName, NOTICE, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, CreateUserMappingStmt::options, PointerGetDatum, PointerIsValid, RelationData::rd_att, recordDependencyOn(), recordDependencyOnOwner(), ROLESPEC_PUBLIC, RoleSpec::roletype, RowExclusiveLock, ForeignServer::serverid, CreateUserMappingStmt::servername, table_close(), table_open(), transformGenericOptions(), CreateUserMappingStmt::user, user_mapping_ddl_aclcheck(), UserMappingOidIndexId, 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 = table_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, Anum_pg_user_mapping_oid,
                            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)));
 
             table_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));
 
     umId = GetNewOidWithIndex(rel, UserMappingOidIndexId,
                               Anum_pg_user_mapping_oid);
     values[Anum_pg_user_mapping_oid - 1] = ObjectIdGetDatum(umId);
     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);
 
     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);
     }
 
     /*
      * Perhaps someday there should be a recordDependencyOnCurrentExtension
      * call here; but since roles aren't members of extensions, it seems like
      * user mappings shouldn't be either.  Note that the grammar and pg_dump
      * would need to be extended too if we change this.
      */
 
     /* Post creation hook for new user mapping */
     InvokeObjectPostCreateHook(UserMappingRelationId, umId, 0);
 
     table_close(rel, RowExclusiveLock);
 
     return myself;
 }

◆ defGetBoolean()

bool defGetBoolean ( DefElem * def )

Definition at line 111 of file define.c.

References DefElem::arg, defGetString(), DefElem::defname, ereport, errcode(), errmsg(), ERROR, intVal, nodeTag, pg_strcasecmp(), and T_Integer.

Referenced by AlterDatabase(), apply_server_options(), apply_table_options(), cluster(), createdb(), CreateExtension(), DefineAggregate(), DefineCollation(), DefineOperator(), DefineType(), dintdict_init(), dsimple_init(), dsynonym_init(), dxsyn_init(), ExecReindex(), ExecVacuum(), ExplainQuery(), file_fdw_validator(), get_file_fdw_attribute_options(), get_vacopt_ternary_value(), GetCommandLogLevel(), parse_output_parameters(), parse_publication_options(), parse_subscription_options(), parseCreateReplSlotOptions(), postgres_fdw_validator(), postgresImportForeignSchema(), postgresIsForeignRelUpdatable(), ProcessCopyOptions(), transformRelOptions(), and UserMappingPasswordRequired().

 {
     /*
      * If no parameter given, assume "true" is meant.
      */
     if (def->arg == NULL)
         return true;
 
     /*
      * Allow 0, 1, "true", "false", "on", "off"
      */
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             switch (intVal(def->arg))
             {
                 case 0:
                     return false;
                 case 1:
                     return true;
                 default:
                     /* otherwise, error out below */
                     break;
             }
             break;
         default:
             {
                 char       *sval = defGetString(def);
 
                 /*
                  * The set of strings accepted here should match up with the
                  * grammar's opt_boolean_or_string production.
                  */
                 if (pg_strcasecmp(sval, "true") == 0)
                     return true;
                 if (pg_strcasecmp(sval, "false") == 0)
                     return false;
                 if (pg_strcasecmp(sval, "on") == 0)
                     return true;
                 if (pg_strcasecmp(sval, "off") == 0)
                     return false;
             }
             break;
     }
     ereport(ERROR,
             (errcode(ERRCODE_SYNTAX_ERROR),
              errmsg("%s requires a Boolean value",
                     def->defname)));
     return false;               /* keep compiler quiet */
 }

◆ defGetInt32()

int32 defGetInt32 ( DefElem * def )

Definition at line 166 of file define.c.

References DefElem::arg, DefElem::defname, ereport, errcode(), errmsg(), ERROR, intVal, nodeTag, and T_Integer.

Referenced by

Functions

Function Documentation

◆ AlterForeignDataWrapper()

◆ AlterForeignDataWrapperOwner()

◆ AlterForeignDataWrapperOwner_oid()

◆ AlterForeignServer()

◆ AlterForeignServerOwner()

◆ AlterForeignServerOwner_oid()

◆ AlterFunction()

◆ AlterOperator()

◆ AlterOpFamily()

◆ AlterStatistics()

◆ AlterTSConfiguration()

◆ AlterTSDictionary()

◆ AlterUserMapping()

◆ CallStmtResultDesc()

◆ CheckIndexCompatible()

◆ ChooseRelationName()

◆ CreateAccessMethod()

◆ CreateCast()

◆ CreateForeignDataWrapper()

◆ CreateForeignServer()

◆ CreateForeignTable()

◆ CreateFunction()

◆ CreateStatistics()

◆ CreateTransform()

◆ CreateUserMapping()

◆ defGetBoolean()

◆ defGetInt32()