#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, List parameterTypes_list, ArrayType allParameterTypes, ArrayType parameterModes, ArrayType parameterNames, List inParameterNames_list, 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)

Oid	StatisticsGetRelation (Oid statId, bool missing_ok)

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 1345 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 589 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 2353 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 1518 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 1012 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, ParseState::p_sourcetext, palloc(), CreateFunctionStmt::parameters, pg_language_aclcheck(), pg_namespace_aclcheck(), PointerGetDatum, ProcedureCreate(), QualifiedNameGetCreationNamespace(), ReleaseSysCache(), CreateFunctionStmt::replace, CreateFunctionStmt::returnType, SearchSysCache1(), CreateFunctionStmt::sql_body, superuser(), and typenameTypeId().

Referenced by ProcessUtilitySlow().

 {
     char       *probin_str;
     char       *prosrc_str;
     Node       *prosqlbody;
     Oid         prorettype;
     bool        returnsSet;
     char       *language;
     Oid         languageOid;
     Oid         languageValidator;
     Node       *transformDefElem = NULL;
     char       *funcname;
     Oid         namespaceId;
     AclResult   aclresult;
     oidvector  *parameterTypes;
     List       *parameterTypes_list = NIL;
     ArrayType  *allParameterTypes;
     ArrayType  *parameterModes;
     ArrayType  *parameterNames;
     List       *inParameterNames_list = NIL;
     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 */
     as_clause = NIL;
     language = NULL;
     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);
 
     if (!language)
     {
         if (stmt->sql_body)
             language = "sql";
         else
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("no language specified")));
     }
 
     /* 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,
                                       &parameterTypes_list,
                                       &allParameterTypes,
                                       &parameterModes,
                                       &parameterNames,
                                       &inParameterNames_list,
                                       &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, stmt->sql_body,
                         parameterTypes_list, inParameterNames_list,
                         &prosrc_str, &probin_str, &prosqlbody,
                         pstate->p_sourcetext);
 
     /*
      * 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 */
                            prosqlbody,
                            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 64 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, CStringGetTextDatum, CreateStatsStmt::defnames, DEPENDENCY_AUTO, DEPENDENCY_NORMAL, equal(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, StatsElem::expr, CreateStatsStmt::exprs, exprType(), 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(), lappend(), lengthof, lfirst, list_length(), lookup_type_cache(), TypeCacheEntry::lt_opr, StatsElem::name, NameGetDatum, namestrcpy(), NIL, nodeToString(), NoLock, NOTICE, ObjectAddressSet, ObjectAddressSubSet, ObjectIdGetDatum, pfree(), pg_class_ownercheck(), PointerGetDatum, qsort, QualifiedNameGetCreationNamespace(), RelationData::rd_att, RelationData::rd_rel, recordDependencyOn(), recordDependencyOnOwner(), recordDependencyOnSingleRelExpr(), 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 ATExecAddStatistics(), and ProcessUtilitySlow().

 {
     int16       attnums[STATS_MAX_DIMENSIONS];
     int         nattnums = 0;
     int         numcols;
     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;
     List       *stxexprs = NIL;
     Datum       exprsDatum;
     Relation    statrel;
     Relation    datarel;
     Relation    rel = NULL;
     Oid         relid;
     ObjectAddress parentobject,
                 myself;
     Datum       types[4];       /* one for each possible type of statistic */
     int         ntypes;
     ArrayType  *stxkind;
     bool        build_ndistinct;
     bool        build_dependencies;
     bool        build_mcv;
     bool        build_expressions;
     bool        requested_type = false;
     int         i;
     ListCell   *cell;
     ListCell   *cell2;
 
     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)));
     }
 
     /*
      * Make sure no more than STATS_MAX_DIMENSIONS columns are used. There
      * might be duplicates and so on, but we'll deal with those later.
      */
     numcols = list_length(stmt->exprs);
     if (numcols > STATS_MAX_DIMENSIONS)
         ereport(ERROR,
                 (errcode(ERRCODE_TOO_MANY_COLUMNS),
                  errmsg("cannot have more than %d columns in statistics",
                         STATS_MAX_DIMENSIONS)));
 
     /*
      * Convert the expression list to a simple array of attnums, but also keep
      * a list of more complex expressions.  While at it, enforce some
      * constraints.
      *
      * XXX We do only the bare minimum to separate simple attribute and
      * complex expressions - for example "(a)" will be treated as a complex
      * expression. No matter how elaborate the check is, there'll always be a
      * way around it, if the user is determined (consider e.g. "(a+0)"), so
      * it's not worth protecting against it.
      */
     foreach(cell, stmt->exprs)
     {
         Node       *expr = (Node *) lfirst(cell);
         StatsElem  *selem;
         HeapTuple   atttuple;
         Form_pg_attribute attForm;
         TypeCacheEntry *type;
 
         /*
          * We should not get anything else than StatsElem, given the grammar.
          * But let's keep it as a safety.
          */
         if (!IsA(expr, StatsElem))
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("only simple column references and expressions are allowed in CREATE STATISTICS")));
 
         selem = (StatsElem *) expr;
 
         if (selem->name)        /* column reference */
         {
             char       *attname;
 
             attname = selem->name;
 
             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))));
 
             attnums[nattnums] = attForm->attnum;
             nattnums++;
             ReleaseSysCache(atttuple);
         }
         else                    /* expression */
         {
             Node       *expr = selem->expr;
             Oid         atttype;
 
             Assert(expr != NULL);
 
             /*
              * Disallow data types without a less-than operator.
              *
              * We ignore this for statistics on a single expression, in which
              * case we'll build the regular statistics only (and that code can
              * deal with such data types).
              */
             if (list_length(stmt->exprs) > 1)
             {
                 atttype = exprType(expr);
                 type = lookup_type_cache(atttype, TYPECACHE_LT_OPR);
                 if (type->lt_opr == InvalidOid)
                     ereport(ERROR,
                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                              errmsg("expression cannot be used in multivariate statistics because its type %s has no default btree operator class",
                                     format_type_be(atttype))));
             }
 
             stxexprs = lappend(stxexprs, expr);
         }
     }
 
     /*
      * Parse the statistics kinds.
      *
      * First check that if this is the case with a single expression, there
      * are no statistics kinds specified (we don't allow that for the simple
      * CREATE STATISTICS form).
      */
     if ((list_length(stmt->exprs) == 1) && (list_length(stxexprs) == 1))
     {
         /* statistics kinds not specified */
         if (list_length(stmt->stat_types) > 0)
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("when building statistics on a single expression, statistics kinds may not be specified")));
     }
 
     /* OK, let's check that we recognize 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 (but only when the
      * statistics is defined on more than one column/expression).
      */
     if ((!requested_type) && (numcols >= 2))
     {
         build_ndistinct = true;
         build_dependencies = true;
         build_mcv = true;
     }
 
     /*
      * When there are non-trivial expressions, build the expression stats
      * automatically. This allows calculating good estimates for stats that
      * consider per-clause estimates (e.g. functional dependencies).
      */
     build_expressions = (list_length(stxexprs) > 0);
 
     /*
      * Check that at least two columns were specified in the statement, or
      * that we're building statistics on a single expression.
      */
     if ((numcols < 2) && (list_length(stxexprs) != 1))
         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 matter for the contents, unlike for
      * indexes, for example).
      */
     qsort(attnums, nattnums, 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 < nattnums; i++)
     {
         if (attnums[i] == attnums[i - 1])
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_COLUMN),
                      errmsg("duplicate column name in statistics definition")));
     }
 
     /*
      * Check for duplicate expressions. We do two loops, counting the
      * occurrences of each expression. This is O(N^2) but we only allow small
      * number of expressions and it's not executed often.
      *
      * XXX We don't cross-check attributes and expressions, because it does
      * not seem worth it. In principle we could check that expressions don't
      * contain trivial attribute references like "(a)", but the reasoning is
      * similar to why we don't bother with extracting columns from
      * expressions. It's either expensive or very easy to defeat for
      * determined user, and there's no risk if we allow such statistics (the
      * statistics is useless, but harmless).
      */
     foreach(cell, stxexprs)
     {
         Node       *expr1 = (Node *) lfirst(cell);
         int         cnt = 0;
 
         foreach(cell2, stxexprs)
         {
             Node       *expr2 = (Node *) lfirst(cell2);
 
             if (equal(expr1, expr2))
                 cnt += 1;
         }
 
         /* every expression should find at least itself */
         Assert(cnt >= 1);
 
         if (cnt > 1)
             ereport(ERROR,
                     (errcode(ERRCODE_DUPLICATE_COLUMN),
                      errmsg("duplicate expression in statistics definition")));
     }
 
     /* Form an int2vector representation of the sorted column list */
     stxkeys = buildint2vector(attnums, nattnums);
 
     /* 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);
     if (build_expressions)
         types[ntypes++] = CharGetDatum(STATS_EXT_EXPRESSIONS);
     Assert(ntypes > 0 && ntypes <= lengthof(types));
     stxkind = construct_array(types, ntypes, CHAROID, 1, true, TYPALIGN_CHAR);
 
     /* convert the expressions (if any) to a text datum */
     if (stxexprs != NIL)
     {
         char       *exprsString;
 
         exprsString = nodeToString(stxexprs);
         exprsDatum = CStringGetTextDatum(exprsString);
         pfree(exprsString);
     }
     else
         exprsDatum = (Datum) 0;
 
     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);
 
     values[Anum_pg_statistic_ext_stxexprs - 1] = exprsDatum;
     if (exprsDatum == (Datum) 0)
         nulls[Anum_pg_statistic_ext_stxexprs - 1] = true;
 
     /* 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;
     datanulls[Anum_pg_statistic_ext_data_stxdexpr - 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);
 
     /* add dependencies for plain column references */
     for (i = 0; i < nattnums; i++)
     {
         ObjectAddressSubSet(parentobject, RelationRelationId, relid, attnums[i]);
         recordDependencyOn(&myself, &parentobject, DEPENDENCY_AUTO);
     }
 
     /*
      * If there are no dependencies on a column, give the statistics an auto
      * dependency on the whole table.  In most cases, this will be redundant,
      * but it might not be if the statistics expressions contain no Vars
      * (which might seem strange but possible). This is consistent with what
      * we do for indexes in index_create.
      *
      * XXX We intentionally don't consider the expressions before adding this
      * dependency, because recordDependencyOnSingleRelExpr may not create any
      * dependencies for whole-row Vars.
      */
     if (!nattnums)
     {
         ObjectAddressSet(parentobject, RelationRelationId, relid);
         recordDependencyOn(&myself, &parentobject, DEPENDENCY_AUTO);
     }
 
     /*
      * Store dependencies on anything mentioned in statistics expressions,
      * just like we do for index expressions.
      */
     if (stxexprs)
         recordDependencyOnSingleRelExpr(&myself,
                                         (Node *) stxexprs,
                                         relid,
                                         DEPENDENCY_NORMAL,
                                         DEPENDENCY_AUTO, false);
 
     /*
      * 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 1792 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;
 }

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