#include "access/stratnum.h"
#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 tableId, IndexStmt *stmt, Oid indexRelationId, Oid parentIndexId, Oid parentConstraintId, int total_parts, bool is_alter_table, bool check_rights, bool check_not_in_use, bool skip_build, bool quiet)

void	ExecReindex (ParseState pstate, const 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, const List attributeList, const List *exclusionOpNames, bool isWithoutOverlaps)

Oid	GetDefaultOpClass (Oid type_id, Oid am_id)

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

void	GetOperatorFromWellKnownStrategy (Oid opclass, Oid rhstype, Oid opid, StrategyNumber strat)

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 (ParseState pstate, 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)

void	RemoveStatisticsDataById (Oid statsOid, bool inh)

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 (ParseState pstate, CreateFdwStmt stmt)

ObjectAddress	AlterForeignDataWrapper (ParseState pstate, 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)

Oid	defGetObjectId (DefElem *def)

List *	defGetQualifiedName (DefElem *def)

TypeName *	defGetTypeName (DefElem *def)

int	defGetTypeLength (DefElem *def)

List *	defGetStringList (DefElem *def)

void	errorConflictingDefElem (DefElem defel, ParseState pstate) pg_attribute_noreturn()

Function Documentation

◆ AlterForeignDataWrapper()

ObjectAddress AlterForeignDataWrapper	(	ParseState *	pstate,
		AlterFdwStmt *	stmt
	)

Definition at line 674 of file foreigncmds.c.

 {
     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 superuser */
     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(pstate, 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;
 }

References CatalogTupleUpdate(), ObjectAddress::classId, CStringGetDatum(), DatumGetPointer(), deleteDependencyRecordsForClass(), DEPENDENCY_NORMAL, ereport, errcode(), errhint(), errmsg(), ERROR, GETSTRUCT, heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, parse_func_options(), PointerGetDatum(), PointerIsValid, recordDependencyOn(), RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, stmt, superuser(), SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), transformGenericOptions(), and WARNING.

Referenced by ProcessUtilitySlow().

◆ AlterForeignDataWrapperOwner()

ObjectAddress AlterForeignDataWrapperOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 275 of file foreigncmds.c.

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

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

Referenced by ExecAlterOwnerStmt().

◆ AlterForeignDataWrapperOwner_oid()

void AlterForeignDataWrapperOwner_oid	(	Oid	fwdId,
		Oid	newOwnerId
	)

Definition at line 313 of file foreigncmds.c.

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

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

Referenced by shdepReassignOwned_Owner().

◆ AlterForeignServer()

ObjectAddress AlterForeignServer ( AlterForeignServerStmt * stmt )

Definition at line 974 of file foreigncmds.c.

 {
     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 (!object_ownercheck(ForeignServerRelationId, 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;
 }

References aclcheck_error(), ACLCHECK_NOT_OWNER, CatalogTupleUpdate(), CStringGetDatum(), CStringGetTextDatum, DatumGetPointer(), ereport, errcode(), errmsg(), ERROR, ForeignDataWrapper::fdwvalidator, GetForeignDataWrapper(), GETSTRUCT, GetUserId(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, OBJECT_FOREIGN_SERVER, object_ownercheck(), ObjectAddressSet, PointerGetDatum(), PointerIsValid, RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, stmt, SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), and transformGenericOptions().

Referenced by ProcessUtilitySlow().

◆ AlterForeignServerOwner()

ObjectAddress AlterForeignServerOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 415 of file foreigncmds.c.

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

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

Referenced by ExecAlterOwnerStmt().

◆ AlterForeignServerOwner_oid()

void AlterForeignServerOwner_oid	(	Oid	srvId,
		Oid	newOwnerId
	)

Definition at line 450 of file foreigncmds.c.

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

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

Referenced by shdepReassignOwned_Owner().

◆ AlterFunction()

ObjectAddress AlterFunction	(	ParseState *	pstate,
		AlterFunctionStmt *	stmt
	)

Definition at line 1358 of file functioncmds.c.

 {
     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 (!object_ownercheck(ProcedureRelationId, 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 = boolVal(strict_item->arg);
     if (security_def_item)
         procForm->prosecdef = boolVal(security_def_item->arg);
     if (leakproof_item)
     {
         procForm->proleakproof = boolVal(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))
         {
             if (changeDependencyFor(ProcedureRelationId, funcOid,
                                     ProcedureRelationId, procForm->prosupport,
                                     newsupport) != 1)
                 elog(ERROR, "could not change support dependency for function %s",
                      get_func_name(funcOid));
         }
         else
         {
             ObjectAddress referenced;
  
             referenced.classId = ProcedureRelationId;
             referenced.objectId = newsupport;
             referenced.objectSubId = 0;
             recordDependencyOn(&address, &referenced, DEPENDENCY_NORMAL);
         }
  
         procForm->prosupport = newsupport;
     }
     if (parallel_item)
         procForm->proparallel = interpret_func_parallel(parallel_item);
     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);
     }
     /* DO NOT put more touches of procForm below here; it's now dangling. */
  
     /* Do the update */
     CatalogTupleUpdate(rel, &tup->t_self, tup);
  
     InvokeObjectPostAlterHook(ProcedureRelationId, funcOid, 0);
  
     table_close(rel, NoLock);
     heap_freetuple(tup);
  
     return address;
 }

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

Referenced by ProcessUtilitySlow().

◆ AlterOperator()

ObjectAddress AlterOperator ( AlterOperatorStmt * stmt )

Definition at line 462 of file operatorcmds.c.

 {
     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;
     List       *commutatorName = NIL;   /* optional commutator operator name */
     Oid         commutatorOid;
     List       *negatorName = NIL;  /* optional negator operator name */
     Oid         negatorOid;
     bool        canMerge = false;
     bool        updateMerges = false;
     bool        canHash = false;
     bool        updateHashes = false;
  
     /* 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;
         }
         else if (strcmp(defel->defname, "commutator") == 0)
         {
             commutatorName = defGetQualifiedName(defel);
         }
         else if (strcmp(defel->defname, "negator") == 0)
         {
             negatorName = defGetQualifiedName(defel);
         }
         else if (strcmp(defel->defname, "merges") == 0)
         {
             canMerge = defGetBoolean(defel);
             updateMerges = true;
         }
         else if (strcmp(defel->defname, "hashes") == 0)
         {
             canHash = defGetBoolean(defel);
             updateHashes = 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)
         {
             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 (!object_ownercheck(OperatorRelationId, oprId, GetUserId()))
         aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
                        NameStr(oprForm->oprname));
  
     /*
      * Look up OIDs for any parameters specified
      */
     if (restrictionName)
         restrictionOid = ValidateRestrictionEstimator(restrictionName);
     else
         restrictionOid = InvalidOid;
     if (joinName)
         joinOid = ValidateJoinEstimator(joinName);
     else
         joinOid = InvalidOid;
  
     if (commutatorName)
     {
         /* commutator has reversed arg types */
         commutatorOid = ValidateOperatorReference(commutatorName,
                                                   oprForm->oprright,
                                                   oprForm->oprleft);
  
         /*
          * We don't need to do anything extra for a self commutator as in
          * OperatorCreate, since the operator surely exists already.
          */
     }
     else
         commutatorOid = InvalidOid;
  
     if (negatorName)
     {
         negatorOid = ValidateOperatorReference(negatorName,
                                                oprForm->oprleft,
                                                oprForm->oprright);
  
         /* Must reject self-negation */
         if (negatorOid == oprForm->oid)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("operator cannot be its own negator")));
     }
     else
     {
         negatorOid = InvalidOid;
     }
  
     /*
      * Check that we're not changing any attributes that might be depended on
      * by plans, while allowing no-op updates.
      */
     if (OidIsValid(commutatorOid) && OidIsValid(oprForm->oprcom) &&
         commutatorOid != oprForm->oprcom)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                  errmsg("operator attribute \"%s\" cannot be changed if it has already been set",
                         "commutator")));
  
     if (OidIsValid(negatorOid) && OidIsValid(oprForm->oprnegate) &&
         negatorOid != oprForm->oprnegate)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                  errmsg("operator attribute \"%s\" cannot be changed if it has already been set",
                         "negator")));
  
     if (updateMerges && oprForm->oprcanmerge && !canMerge)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                  errmsg("operator attribute \"%s\" cannot be changed if it has already been set",
                         "merges")));
  
     if (updateHashes && oprForm->oprcanhash && !canHash)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                  errmsg("operator attribute \"%s\" cannot be changed if it has already been set",
                         "hashes")));
  
     /* Perform additional checks, like OperatorCreate does */
     OperatorValidateParams(oprForm->oprleft,
                            oprForm->oprright,
                            oprForm->oprresult,
                            OidIsValid(commutatorOid),
                            OidIsValid(negatorOid),
                            OidIsValid(restrictionOid),
                            OidIsValid(joinOid),
                            canMerge,
                            canHash);
  
     /* 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] = ObjectIdGetDatum(restrictionOid);
     }
     if (updateJoin)
     {
         replaces[Anum_pg_operator_oprjoin - 1] = true;
         values[Anum_pg_operator_oprjoin - 1] = ObjectIdGetDatum(joinOid);
     }
     if (OidIsValid(commutatorOid))
     {
         replaces[Anum_pg_operator_oprcom - 1] = true;
         values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(commutatorOid);
     }
     if (OidIsValid(negatorOid))
     {
         replaces[Anum_pg_operator_oprnegate - 1] = true;
         values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(negatorOid);
     }
     if (updateMerges)
     {
         replaces[Anum_pg_operator_oprcanmerge - 1] = true;
         values[Anum_pg_operator_oprcanmerge - 1] = BoolGetDatum(canMerge);
     }
     if (updateHashes)
     {
         replaces[Anum_pg_operator_oprcanhash - 1] = true;
         values[Anum_pg_operator_oprcanhash - 1] = BoolGetDatum(canHash);
     }
  
     tup = heap_modify_tuple(tup, RelationGetDescr(catalog),
                             values, nulls, replaces);
  
     CatalogTupleUpdate(catalog, &tup->t_self, tup);
  
     address = makeOperatorDependencies(tup, false, true);
  
     if (OidIsValid(commutatorOid) || OidIsValid(negatorOid))
         OperatorUpd(oprId, commutatorOid, negatorOid, false);
  
     InvokeObjectPostAlterHook(OperatorRelationId, oprId, 0);
  
     table_close(catalog, NoLock);
  
     return address;
 }

References aclcheck_error(), ACLCHECK_NOT_OWNER, DefElem::arg, BoolGetDatum(), CatalogTupleUpdate(), defGetBoolean(), 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, object_ownercheck(), ObjectIdGetDatum(), OidIsValid, OperatorUpd(), OperatorValidateParams(), RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, stmt, HeapTupleData::t_self, table_close(), table_open(), ValidateJoinEstimator(), ValidateOperatorReference(), ValidateRestrictionEstimator(), and values.

Referenced by ProcessUtilitySlow().

◆ AlterOpFamily()

Oid AlterOpFamily ( AlterOpFamilyStmt * stmt )

Definition at line 817 of file opclasscmds.c.

 {
     Oid         amoid,          /* our AM's oid */
                 opfamilyoid;    /* oid of opfamily */
     int         maxOpNumber,    /* amstrategies value */
                 optsProcNumber, /* amoptsprocnum 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;
 }

References AlterOpFamilyAdd(), AlterOpFamilyDrop(), IndexAmRoutine::amoptsprocnum, IndexAmRoutine::amstrategies, IndexAmRoutine::amsupport, CStringGetDatum(), ereport, errcode(), errmsg(), ERROR, get_opfamily_oid(), GetIndexAmRoutineByAmId(), GETSTRUCT, HeapTupleIsValid, ReleaseSysCache(), SearchSysCache1(), stmt, and superuser().

Referenced by ProcessUtilitySlow().

◆ AlterStatistics()

ObjectAddress AlterStatistics ( AlterStatsStmt * stmt )

Definition at line 599 of file statscmds.c.

 {
     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 = 0;
     bool        newtarget_default;
  
     /* -1 was used in previous versions for the default setting */
     if (stmt->stxstattarget && intVal(stmt->stxstattarget) != -1)
     {
         newtarget = intVal(stmt->stxstattarget);
         newtarget_default = false;
     }
     else
         newtarget_default = true;
  
     if (!newtarget_default)
     {
         /* Limit statistics target to a sane range */
         if (newtarget < 0)
         {
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                      errmsg("statistics target %d is too low",
                             newtarget)));
         }
         else if (newtarget > MAX_STATISTICS_TARGET)
         {
             newtarget = MAX_STATISTICS_TARGET;
             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 object
      * 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));
     if (!HeapTupleIsValid(oldtup))
         elog(ERROR, "cache lookup failed for extended statistics object %u", stxoid);
  
     /* Must be owner of the existing statistics object */
     if (!object_ownercheck(StatisticExtRelationId, 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;
     if (!newtarget_default)
         repl_val[Anum_pg_statistic_ext_stxstattarget - 1] = Int16GetDatum(newtarget);
     else
         repl_null[Anum_pg_statistic_ext_stxstattarget - 1] = true;
  
     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;
 }

References aclcheck_error(), ACLCHECK_NOT_OWNER, Assert, CatalogTupleUpdate(), DeconstructQualifiedName(), elog, ereport, errcode(), errmsg(), ERROR, get_statistics_object_oid(), GetUserId(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, Int16GetDatum(), intVal, InvalidObjectAddress, InvokeObjectPostAlterHook, MAX_STATISTICS_TARGET, NameListToString(), NOTICE, object_ownercheck(), OBJECT_STATISTIC_EXT, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), stmt, HeapTupleData::t_self, table_close(), table_open(), and WARNING.

Referenced by ProcessUtilitySlow().

◆ AlterTSConfiguration()

ObjectAddress AlterTSConfiguration ( AlterTSConfigurationStmt * stmt )

Definition at line 1156 of file tsearchcmds.c.

 {
     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 (!object_ownercheck(TSConfigRelationId, 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;
 }

References aclcheck_error(), ACLCHECK_NOT_OWNER, DropConfigurationMapping(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, GetTSConfigTuple(), GetUserId(), HeapTupleIsValid, InvokeObjectPostAlterHook, makeConfigurationDependencies(), MakeConfigurationMapping(), NameListToString(), object_ownercheck(), OBJECT_TSCONFIGURATION, ObjectAddressSet, ReleaseSysCache(), RowExclusiveLock, stmt, table_close(), and table_open().

Referenced by ProcessUtilitySlow().

◆ AlterTSDictionary()

ObjectAddress AlterTSDictionary ( AlterTSDictionaryStmt * stmt )

Definition at line 493 of file tsearchcmds.c.

 {
     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 (!object_ownercheck(TSDictionaryRelationId, 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;
 }

References aclcheck_error(), ACLCHECK_NOT_OWNER, DefElem::arg, CatalogTupleUpdate(), DefElem::defname, deserialize_deflist(), elog, ERROR, foreach_delete_current, get_ts_dict_oid(), GETSTRUCT, GetUserId(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvokeObjectPostAlterHook, lappend(), lfirst, NameListToString(), NIL, object_ownercheck(), OBJECT_TSDICTIONARY, ObjectAddressSet, ObjectIdGetDatum(), PointerGetDatum(), RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), serialize_deflist(), stmt, SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), and verify_dictoptions().

Referenced by ProcessUtilitySlow().

◆ AlterUserMapping()

ObjectAddress AlterUserMapping ( AlterUserMappingStmt * stmt )

Definition at line 1226 of file foreigncmds.c.

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

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, PointerGetDatum(), PointerIsValid, RelationGetDescr, ROLESPEC_PUBLIC, RoleSpec::roletype, RowExclusiveLock, SearchSysCacheCopy1, ForeignServer::serverid, stmt, SysCacheGetAttr(), HeapTupleData::t_self, table_close(), table_open(), transformGenericOptions(), and user_mapping_ddl_aclcheck().

Referenced by ProcessUtilitySlow().

◆ CallStmtResultDesc()

TupleDesc CallStmtResultDesc ( CallStmt * stmt )

Definition at line 2380 of file functioncmds.c.

 {
     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);
  
     /*
      * The result of build_function_result_tupdesc_t has the right column
      * names, but it just has the declared output argument types, which is the
      * wrong thing in polymorphic cases.  Get the correct types by examining
      * stmt->outargs.  We intentionally keep the atttypmod as -1 and the
      * attcollation as the type's default, since that's always the appropriate
      * thing for function outputs; there's no point in considering any
      * additional info available from outargs.  Note that tupdesc is null if
      * there are no outargs.
      */
     if (tupdesc)
     {
         Assert(tupdesc->natts == list_length(stmt->outargs));
         for (int i = 0; i < tupdesc->natts; i++)
         {
             Form_pg_attribute att = TupleDescAttr(tupdesc, i);
             Node       *outarg = (Node *) list_nth(stmt->outargs, i);
  
             TupleDescInitEntry(tupdesc,
                                i + 1,
                                NameStr(att->attname),
                                exprType(outarg),
                                -1,
                                0);
         }
     }
  
     return tupdesc;
 }

References Assert, build_function_result_tupdesc_t(), elog, ERROR, exprType(), FuncExpr::funcid, HeapTupleIsValid, i, list_length(), list_nth(), NameStr, TupleDescData::natts, ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache1(), stmt, TupleDescAttr, and TupleDescInitEntry().

Referenced by UtilityTupleDescriptor().

◆ CheckIndexCompatible()

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

Definition at line 179 of file indexcmds.c.

 {
     bool        isconstraint;
     Oid        *typeIds;
     Oid        *collationIds;
     Oid        *opclassIds;
     Datum      *opclassOptions;
     Oid         accessMethodId;
     Oid         relationId;
     HeapTuple   tuple;
     Form_pg_index indexForm;
     Form_pg_am  accessMethodForm;
     IndexAmRoutine *amRoutine;
     bool        amcanorder;
     bool        amsummarizing;
     int16      *coloptions;
     IndexInfo  *indexInfo;
     int         numberOfAttributes;
     int         old_natts;
     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;
     amsummarizing = amRoutine->amsummarizing;
  
     /*
      * 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 failed later.  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, false, amsummarizing, isWithoutOverlaps);
     typeIds = palloc_array(Oid, numberOfAttributes);
     collationIds = palloc_array(Oid, numberOfAttributes);
     opclassIds = palloc_array(Oid, numberOfAttributes);
     opclassOptions = palloc_array(Datum, numberOfAttributes);
     coloptions = palloc_array(int16, numberOfAttributes);
     ComputeIndexAttrs(indexInfo,
                       typeIds, collationIds, opclassIds, opclassOptions,
                       coloptions, attributeList,
                       exclusionOpNames, relationId,
                       accessMethodName, accessMethodId,
                       amcanorder, isconstraint, isWithoutOverlaps, InvalidOid,
                       0, NULL);
  
     /* 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 = SysCacheGetAttrNotNull(INDEXRELID, tuple, Anum_pg_index_indcollation);
     old_indcollation = (oidvector *) DatumGetPointer(d);
  
     d = SysCacheGetAttrNotNull(INDEXRELID, tuple, Anum_pg_index_indclass);
     old_indclass = (oidvector *) DatumGetPointer(d);
  
     ret = (memcmp(old_indclass->values, opclassIds, old_natts * sizeof(Oid)) == 0 &&
            memcmp(old_indcollation->values, collationIds, 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(opclassIds[i])) &&
             TupleDescAttr(irel->rd_att, i)->atttypid != typeIds[i])
         {
             ret = false;
             break;
         }
     }
  
     /* Any change in opclass options break compatibility. */
     if (ret)
     {
         Datum      *oldOpclassOptions = palloc_array(Datum, old_natts);
  
         for (i = 0; i < old_natts; i++)
             oldOpclassOptions[i] = get_attoptions(oldId, i + 1);
  
         ret = CompareOpclassOptions(oldOpclassOptions, opclassOptions, old_natts);
  
         pfree(oldOpclassOptions);
     }
  
     /* 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 != typeIds[i])
                 {
                     ret = false;
                     break;
                 }
             }
         }
     }
  
     index_close(irel, NoLock);
     return ret;
 }

References AccessShareLock, IndexAmRoutine::amcanorder, IndexAmRoutine::amsummarizing, Assert, CompareOpclassOptions(), ComputeIndexAttrs(), DatumGetPointer(), elog, ereport, errcode(), errmsg(), ERROR, get_attoptions(), get_opclass_input_type(), GetIndexAmRoutine(), GETSTRUCT, heap_attisnull(), HeapTupleIsValid, i, IndexInfo::ii_ExclusionOps, index_close(), INDEX_MAX_KEYS, index_open(), IndexGetRelation(), InvalidOid, list_length(), makeIndexInfo(), NIL, NoLock, ObjectIdGetDatum(), op_input_types(), palloc_array, pfree(), PointerGetDatum(), RelationData::rd_att, RelationGetExclusionInfo(), ReleaseSysCache(), SearchSysCache1(), SysCacheGetAttrNotNull(), TupleDescAttr, and oidvector::values.

Referenced by TryReuseIndex().

◆ ChooseRelationName()

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

Definition at line 2615 of file indexcmds.c.

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

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

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

◆ CreateAccessMethod()

ObjectAddress CreateAccessMethod ( CreateAmStmt * stmt )

Definition at line 43 of file amcmds.c.

 {
     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 superuser */
     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;
 }

References CatalogTupleInsert(), CharGetDatum(), ObjectAddress::classId, CStringGetDatum(), DEPENDENCY_NORMAL, DirectFunctionCall1, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errhint(), errmsg(), ERROR, GetNewOidWithIndex(), GetSysCacheOid1, heap_form_tuple(), heap_freetuple(), InvokeObjectPostCreateHook, lookup_am_handler_func(), namein(), ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, recordDependencyOn(), recordDependencyOnCurrentExtension(), RelationGetDescr, RowExclusiveLock, stmt, superuser(), table_close(), table_open(), and values.

Referenced by ProcessUtilitySlow().

◆ CreateCast()

ObjectAddress CreateCast ( CreateCastStmt * stmt )

Definition at line 1536 of file functioncmds.c.

 {
     Oid         sourcetypeid;
     Oid         targettypeid;
     char        sourcetyptype;
     char        targettyptype;
     Oid         funcid;
     Oid         incastid = InvalidOid;
     Oid         outcastid = InvalidOid;
     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 (!object_ownercheck(TypeRelationId, sourcetypeid, GetUserId())
         && !object_ownercheck(TypeRelationId, 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 = object_aclcheck(TypeRelationId, sourcetypeid, GetUserId(), ACL_USAGE);
     if (aclresult != ACLCHECK_OK)
         aclcheck_error_type(aclresult, sourcetypeid);
  
     aclresult = object_aclcheck(TypeRelationId, 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 (!IsBinaryCoercibleWithCast(sourcetypeid,
                                        procstruct->proargtypes.values[0],
                                        &incastid))
             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 (!IsBinaryCoercibleWithCast(procstruct->prorettype,
                                        targettypeid,
                                        &outcastid))
             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, array, range and enum 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 such a type.  But we disallow it anyway, as
          * in practice such a cast is surely a mistake.  You can always work
          * around that by writing a cast function.
          *
          * NOTE: if we ever have a kind of container type that doesn't need to
          * be rejected for this reason, we'd likely need to recursively apply
          * all of these same checks to the contained type(s).
          */
         if (sourcetyptype == TYPTYPE_COMPOSITE ||
             targettyptype == TYPTYPE_COMPOSITE)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("composite 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")));
  
         if (sourcetyptype == TYPTYPE_RANGE ||
             targettyptype == TYPTYPE_RANGE ||
             sourcetyptype == TYPTYPE_MULTIRANGE ||
             targettyptype == TYPTYPE_MULTIRANGE)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                      errmsg("range 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")));
  
         /*
          * 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, incastid, outcastid,
                         castcontext, castmethod, DEPENDENCY_NORMAL);
     return myself;
 }

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, CastCreate(), COERCION_ASSIGNMENT, COERCION_EXPLICIT, COERCION_IMPLICIT, DEPENDENCY_NORMAL, elog, ereport, errcode(), errmsg(), ERROR, format_type_be(), get_element_type(), get_typlenbyvalalign(), get_typtype(), GETSTRUCT, GetUserId(), HeapTupleIsValid, InvalidOid, IsBinaryCoercibleWithCast(), LookupFuncWithArgs(), object_aclcheck(), OBJECT_FUNCTION, object_ownercheck(), ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), SearchSysCache1(), stmt, superuser(), TypeNameToString(), typenameTypeId(), and WARNING.

Referenced by ProcessUtilitySlow().

◆ CreateForeignDataWrapper()

ObjectAddress CreateForeignDataWrapper	(	ParseState *	pstate,
		CreateFdwStmt *	stmt
	)

Definition at line 558 of file foreigncmds.c.

 {
     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 superuser */
     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(pstate, 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;
 }

References CatalogTupleInsert(), ObjectAddress::classId, CStringGetDatum(), DatumGetPointer(), DEPENDENCY_NORMAL, DirectFunctionCall1, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errhint(), errmsg(), ERROR, GetForeignDataWrapperByName(), GetNewOidWithIndex(), GetUserId(), heap_form_tuple(), heap_freetuple(), InvokeObjectPostCreateHook, namein(), ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, parse_func_options(), PointerGetDatum(), PointerIsValid, RelationData::rd_att, recordDependencyOn(), recordDependencyOnCurrentExtension(), recordDependencyOnOwner(), RowExclusiveLock, stmt, superuser(), table_close(), table_open(), transformGenericOptions(), and values.

Referenced by ProcessUtilitySlow().

◆ CreateForeignServer()

ObjectAddress CreateForeignServer ( CreateForeignServerStmt * stmt )

Definition at line 838 of file foreigncmds.c.

 {
     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.  If there is
      * one, do nothing if IF NOT EXISTS was specified.
      */
     srvId = get_foreign_server_oid(stmt->servername, true);
     if (OidIsValid(srvId))
     {
         if (stmt->if_not_exists)
         {
             /*
              * If we are in an extension script, insist that the pre-existing
              * object be a member of the extension, to avoid security risks.
              */
             ObjectAddressSet(myself, ForeignServerRelationId, srvId);
             checkMembershipInCurrentExtension(&myself);
  
             /* OK to skip */
             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 = object_aclcheck(ForeignDataWrapperRelationId, 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;
 }

References ACL_USAGE, aclcheck_error(), ACLCHECK_OK, CatalogTupleInsert(), checkMembershipInCurrentExtension(), ObjectAddress::classId, CStringGetDatum(), CStringGetTextDatum, DatumGetPointer(), DEPENDENCY_NORMAL, DirectFunctionCall1, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, ForeignDataWrapper::fdwid, ForeignDataWrapper::fdwname, ForeignDataWrapper::fdwvalidator, get_foreign_server_oid(), GetForeignDataWrapperByName(), GetNewOidWithIndex(), GetUserId(), heap_form_tuple(), heap_freetuple(), InvalidObjectAddress, InvokeObjectPostCreateHook, namein(), NOTICE, object_aclcheck(), OBJECT_FDW, ObjectAddressSet, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, PointerGetDatum(), PointerIsValid, RelationData::rd_att, recordDependencyOn(), recordDependencyOnCurrentExtension(), recordDependencyOnOwner(), RowExclusiveLock, stmt, table_close(), table_open(), transformGenericOptions(), and values.

Referenced by ProcessUtilitySlow().

◆ CreateForeignTable()

void CreateForeignTable	(	CreateForeignTableStmt *	stmt,
		Oid	relid
	)

Definition at line 1404 of file foreigncmds.c.

 {
     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 = object_aclcheck(ForeignServerRelationId, 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);
 }

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_aclcheck(), OBJECT_FOREIGN_SERVER, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, PointerGetDatum(), PointerIsValid, RelationData::rd_att, recordDependencyOn(), RowExclusiveLock, ForeignServer::serverid, ForeignServer::servername, stmt, table_close(), table_open(), transformGenericOptions(), and values.

Referenced by ProcessUtilitySlow().

◆ CreateFunction()

ObjectAddress CreateFunction	(	ParseState *	pstate,
		CreateFunctionStmt *	stmt
	)

Definition at line 1026 of file functioncmds.c.

 {
     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 = object_aclcheck(NamespaceRelationId, 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 = object_aclcheck(LanguageRelationId, 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 (trftypes_list != NIL)
     {
         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_builtin(arr, list_length(trftypes_list), OIDOID);
     }
     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);
 }

References ACL_CREATE, ACL_USAGE, aclcheck_error(), ACLCHECK_NO_PRIV, ACLCHECK_OK, Assert, castNode, compute_function_attributes(), compute_return_type(), construct_array_builtin(), ereport, errcode(), errhint(), errmsg(), ERROR, extension_file_exists(), format_type_be(), funcname, get_base_element_type(), get_namespace_name(), get_transform_oid(), GETSTRUCT, GetUserId(), HeapTupleIsValid, i, interpret_AS_clause(), interpret_function_parameter_list(), InvalidOid, lappend_oid(), lfirst_node, lfirst_oid, list_length(), NameStr, NIL, object_aclcheck(), OBJECT_FUNCTION, OBJECT_LANGUAGE, OBJECT_PROCEDURE, OBJECT_SCHEMA, ObjectIdGetDatum(), OidIsValid, ParseState::p_sourcetext, palloc(), PointerGetDatum(), ProcedureCreate(), QualifiedNameGetCreationNamespace(), ReleaseSysCache(), SearchSysCache1(), stmt, superuser(), and typenameTypeId().

Referenced by ProcessUtilitySlow().

◆ CreateStatistics()

ObjectAddress CreateStatistics ( CreateStatsStmt * stmt )

Definition at line 62 of file statscmds.c.

 {
     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];
     int2vector *stxkeys;
     List       *stxexprs = NIL;
     Datum       exprsDatum;
     Relation    statrel;
     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("cannot define statistics for relation \"%s\"",
                             RelationGetRelationName(rel)),
                      errdetail_relkind_not_supported(rel->rd_rel->relkind)));
  
         /* You must own the relation to create stats on it */
         if (!object_ownercheck(RelationRelationId, 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, put the object in the same namespace as the relation, and cons
      * up a name for it.  (This can happen either via "CREATE STATISTICS ..."
      * or via "CREATE TABLE ... (LIKE)".)
      */
     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)
         {
             /*
              * Since stats objects aren't members of extensions (see comments
              * below), no need for checkMembershipInCurrentExtension here.
              */
             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 - we don't allow extended statistics on system attributes,
      * and we require the data type to have a less-than operator.
      *
      * There are many ways to "mask" a simple attribute reference as an
      * expression, for example "(a+0)" etc. We can't possibly detect all of
      * them, but we handle at least the simple case with the attribute in
      * parens. There'll always be a way around this, if the user is determined
      * (like the "(a+0)" example), but this makes it somewhat consistent with
      * how indexes treat attributes/expressions.
      */
     foreach(cell, stmt->exprs)
     {
         StatsElem  *selem = lfirst_node(StatsElem, cell);
  
         if (selem->name)        /* column reference */
         {
             char       *attname;
             HeapTuple   atttuple;
             Form_pg_attribute attForm;
             TypeCacheEntry *type;
  
             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 if (IsA(selem->expr, Var)) /* column reference in parens */
         {
             Var        *var = (Var *) selem->expr;
             TypeCacheEntry *type;
  
             /* Disallow use of system attributes in extended stats */
             if (var->varattno <= 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(var->vartype, 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",
                                 get_attname(relid, var->varattno, false), format_type_be(var->vartype))));
  
             attnums[nattnums] = var->varattno;
             nattnums++;
         }
         else                    /* expression */
         {
             Node       *expr = selem->expr;
             Oid         atttype;
             TypeCacheEntry *type;
             Bitmapset  *attnums = NULL;
             int         k;
  
             Assert(expr != NULL);
  
             /* Disallow expressions referencing system attributes. */
             pull_varattnos(expr, 1, &attnums);
  
             k = -1;
             while ((k = bms_next_member(attnums, k)) >= 0)
             {
                 AttrNumber  attnum = k + FirstLowInvalidHeapAttributeNumber;
  
                 if (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.
              *
              * 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 (stmt->stat_types != NIL)
             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(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 = (stxexprs != NIL);
  
     /*
      * 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_builtin(types, ntypes, CHAROID);
  
     /* 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_stxowner - 1] = ObjectIdGetDatum(stxowner);
     values[Anum_pg_statistic_ext_stxkeys - 1] = PointerGetDatum(stxkeys);
     nulls[Anum_pg_statistic_ext_stxstattarget - 1] = true;
     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);
  
     /*
      * We used to create the pg_statistic_ext_data tuple too, but it's not
      * clear what value should the stxdinherit flag have (it depends on
      * whether the rel is partitioned, contains data, etc.)
      */
  
     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 object 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;
 }

References aclcheck_error(), ACLCHECK_NOT_OWNER, allowSystemTableMods, Assert, attname, attnum, bms_next_member(), buildint2vector(), CacheInvalidateRelcache(), CatalogTupleInsert(), CharGetDatum(), ChooseExtendedStatisticName(), ChooseExtendedStatisticNameAddition(), compare_int16(), construct_array_builtin(), CreateComments(), CStringGetDatum(), CStringGetTextDatum, DEPENDENCY_AUTO, DEPENDENCY_NORMAL, equal(), ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errdetail_relkind_not_supported(), errmsg(), ERROR, StatsElem::expr, exprType(), FirstLowInvalidHeapAttributeNumber, format_type_be(), get_attname(), get_relkind_objtype(), GetNewOidWithIndex(), GETSTRUCT, GetUserId(), heap_form_tuple(), heap_freetuple(), HeapTupleIsValid, i, if(), InvalidObjectAddress, InvalidOid, InvokeObjectPostCreateHook, IsA, IsSystemRelation(), lappend(), lengthof, lfirst, lfirst_node, list_length(), lookup_type_cache(), StatsElem::name, NameGetDatum(), namestrcpy(), NIL, nodeToString(), NoLock, NOTICE, object_ownercheck(), ObjectAddressSet, ObjectAddressSubSet, ObjectIdGetDatum(), pfree(), PointerGetDatum(), pull_varattnos(), qsort, QualifiedNameGetCreationNamespace(), RelationData::rd_att, RelationData::rd_rel, recordDependencyOn(), recordDependencyOnOwner(), recordDependencyOnSingleRelExpr(), relation_close(), relation_openrv(), RelationGetNamespace, RelationGetRelationName, RelationGetRelid, ReleaseSysCache(), RowExclusiveLock, SearchSysCacheAttName(), SearchSysCacheExists2, ShareUpdateExclusiveLock, STATS_MAX_DIMENSIONS, stmt, strVal, table_open(), type, TYPECACHE_LT_OPR, types, values, and Var::varattno.

Referenced by ATExecAddStatistics(), and ProcessUtilitySlow().

◆ CreateTransform()

ObjectAddress CreateTransform ( CreateTransformStmt * stmt )

Definition at line 1829 of file functioncmds.c.

 {
     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] = {0};
     bool        replaces[Natts_pg_transform] = {0};
     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 (!object_ownercheck(TypeRelationId, typeid, GetUserId()))
         aclcheck_error_type(ACLCHECK_NOT_OWNER, typeid);
  
     aclresult = object_aclcheck(TypeRelationId, typeid, GetUserId(), ACL_USAGE);
     if (aclresult != ACLCHECK_OK)
         aclcheck_error_type(aclresult, typeid);
  
     /*
      * Get the language
      */
     langid = get_language_oid(stmt->lang, false);
  
     aclresult = object_aclcheck(LanguageRelationId, 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 (!object_ownercheck(ProcedureRelationId, fromsqlfuncid, GetUserId()))
             aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, NameListToString(stmt->fromsql->objname));
  
         aclresult = object_aclcheck(ProcedureRelationId, 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 (!object_ownercheck(ProcedureRelationId, tosqlfuncid, GetUserId()))
             aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, NameListToString(stmt->tosql->objname));
  
         aclresult = object_aclcheck(ProcedureRelationId, 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);
  
     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)));
  
         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;
 }

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(), get_language_oid(), get_typtype(), GetNewOidWithIndex(), GETSTRUCT, GetUserId(), heap_form_tuple(), heap_freetuple(), heap_modify_tuple(), HeapTupleIsValid, InvalidOid, InvokeObjectPostCreateHook, LookupFuncWithArgs(), NameListToString(), new_object_addresses(), object_aclcheck(), OBJECT_FUNCTION, OBJECT_LANGUAGE, object_ownercheck(), ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, record_object_address_dependencies(), recordDependencyOnCurrentExtension(), RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), SearchSysCache2(), stmt, HeapTupleData::t_self, table_close(), table_open(), TypeNameToString(), typenameTypeId(), and values.

Referenced by ProcessUtilitySlow().

◆ CreateUserMapping()

ObjectAddress CreateUserMapping ( CreateUserMappingStmt * stmt )

Definition at line 1100 of file foreigncmds.c.

 {
     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)
         {
             /*
              * Since user mappings aren't members of extensions (see comments
              * below), no need for checkMembershipInCurrentExtension here.
              */
             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;
 }

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(), InvalidObjectAddress, InvokeObjectPostCreateHook, MappingUserName, NOTICE, ObjectAddress::objectId, ObjectIdGetDatum(), ObjectAddress::objectSubId, OidIsValid, PointerGetDatum(), PointerIsValid, RelationData::rd_att, recordDependencyOn(), recordDependencyOnOwner(), ROLESPEC_PUBLIC, RoleSpec::roletype, RowExclusiveLock, ForeignServer::serverid, stmt, table_close(), table_open(), transformGenericOptions(), user_mapping_ddl_aclcheck(), and values.

Referenced by ProcessUtilitySlow().

◆ defGetBoolean()

bool defGetBoolean ( DefElem * def )

Definition at line 107 of file define.c.

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

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

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

◆ defGetInt32()

int32 defGetInt32 ( DefElem * def )

Definition at line 162 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires an integer value",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return (int32) intVal(def->arg);
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("%s requires an integer value",
                             def->defname)));
     }
     return 0;                   /* keep compiler quiet */
 }

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

Referenced by AlterDatabase(), ATExecSetIdentity(), createdb(), DefineAggregate(), and ExecVacuum().

◆ defGetInt64()

int64 defGetInt64 ( DefElem * def )

Definition at line 186 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a numeric value",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return (int64) intVal(def->arg);
         case T_Float:
  
             /*
              * Values too large for int4 will be represented as Float
              * constants by the lexer.  Accept these if they are valid int8
              * strings.
              */
             return DatumGetInt64(DirectFunctionCall1(int8in,
                                                      CStringGetDatum(castNode(Float, def->arg)->fval)));
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("%s requires a numeric value",
                             def->defname)));
     }
     return 0;                   /* keep compiler quiet */
 }

References DefElem::arg, castNode, CStringGetDatum(), DatumGetInt64(), DefElem::defname, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, int8in(), intVal, and nodeTag.

Referenced by defGetCopyRejectLimitOption(), init_params(), and parse_basebackup_options().

◆ defGetNumeric()

double defGetNumeric ( DefElem * def )

Definition at line 81 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a numeric value",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return (double) intVal(def->arg);
         case T_Float:
             return floatVal(def->arg);
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("%s requires a numeric value",
                             def->defname)));
     }
     return 0;                   /* keep compiler quiet */
 }

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

Referenced by AlterFunction(), and compute_function_attributes().

◆ defGetObjectId()

Oid defGetObjectId ( DefElem * def )

Definition at line 219 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a numeric value",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return (Oid) intVal(def->arg);
         case T_Float:
  
             /*
              * Values too large for int4 will be represented as Float
              * constants by the lexer.  Accept these if they are valid OID
              * strings.
              */
             return DatumGetObjectId(DirectFunctionCall1(oidin,
                                                         CStringGetDatum(castNode(Float, def->arg)->fval)));
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("%s requires a numeric value",
                             def->defname)));
     }
     return 0;                   /* keep compiler quiet */
 }

References DefElem::arg, castNode, CStringGetDatum(), DatumGetObjectId(), DefElem::defname, DirectFunctionCall1, ereport, errcode(), errmsg(), ERROR, intVal, nodeTag, and oidin().

Referenced by createdb().

◆ defGetQualifiedName()

List* defGetQualifiedName ( DefElem * def )

Definition at line 252 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a parameter",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_TypeName:
             return ((TypeName *) def->arg)->names;
         case T_List:
             return (List *) def->arg;
         case T_String:
             /* Allow quoted name for backwards compatibility */
             return list_make1(def->arg);
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("argument of %s must be a name",
                             def->defname)));
     }
     return NIL;                 /* keep compiler quiet */
 }

References DefElem::arg, DefElem::defname, ereport, errcode(), errmsg(), ERROR, list_make1, NIL, and nodeTag.

Referenced by AlterOperator(), AlterType(), DefineAggregate(), DefineCollation(), DefineOperator(), DefineRange(), DefineTSConfiguration(), DefineTSDictionary(), DefineType(), get_ts_parser_func(), get_ts_template_func(), init_params(), and interpret_func_support().

◆ defGetString()

char* defGetString ( DefElem * def )

Definition at line 48 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a parameter",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return psprintf("%ld", (long) intVal(def->arg));
         case T_Float:
             return castNode(Float, def->arg)->fval;
         case T_Boolean:
             return boolVal(def->arg) ? "true" : "false";
         case T_String:
             return strVal(def->arg);
         case T_TypeName:
             return TypeNameToString((TypeName *) def->arg);
         case T_List:
             return NameListToString((List *) def->arg);
         case T_A_Star:
             return pstrdup("*");
         default:
             elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg));
     }
     return NULL;                /* keep compiler quiet */
 }

References DefElem::arg, boolVal, castNode, DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, intVal, NameListToString(), nodeTag, psprintf(), pstrdup(), strVal, and TypeNameToString().

Referenced by AlterDatabase(), AlterType(), apply_server_options(), apply_table_options(), check_selective_binary_conversion(), createdb(), CreateExtension(), defGetBoolean(), defGetCopyHeaderChoice(), defGetCopyLogVerbosityChoice(), defGetCopyOnErrorChoice(), defGetStreamingMode(), defGetTypeLength(), DefineAggregate(), DefineCollation(), DefineType(), deparseAnalyzeSql(), deparseColumnRef(), deparseRelation(), dintdict_init(), dispell_init(), dsimple_init(), dsnowball_init(), dsynonym_init(), dxsyn_init(), ExecReindex(), ExecVacuum(), ExplainQuery(), ExplainResultDesc(), ExtractConnectionOptions(), extractModify(), file_fdw_validator(), fileGetOptions(), get_batch_size_option(), GrantRole(), optionListToArray(), parse_basebackup_options(), parse_output_parameters(), parse_publication_options(), parse_subscription_options(), parseCreateReplSlotOptions(), postgres_fdw_validator(), postgresAcquireSampleRowsFunc(), ProcessCopyOptions(), prsd_headline(), serialize_deflist(), thesaurus_init(), transformRelOptions(), and unaccent_init().

◆ defGetStringList()

List* defGetStringList ( DefElem * def )

Definition at line 356 of file define.c.

 {
     ListCell   *cell;
  
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a parameter",
                         def->defname)));
     if (nodeTag(def->arg) != T_List)
         elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg));
  
     foreach(cell, (List *) def->arg)
     {
         Node       *str = (Node *) lfirst(cell);
  
         if (!IsA(str, String))
             elog(ERROR, "unexpected node type in name list: %d",
                  (int) nodeTag(str));
     }
  
     return (List *) def->arg;
 }

References DefElem::arg, DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, IsA, lfirst, nodeTag, and str.

◆ defGetTypeLength()

int defGetTypeLength ( DefElem * def )

Definition at line 312 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a parameter",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_Integer:
             return intVal(def->arg);
         case T_Float:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("%s requires an integer value",
                             def->defname)));
             break;
         case T_String:
             if (pg_strcasecmp(strVal(def->arg), "variable") == 0)
                 return -1;      /* variable length */
             break;
         case T_TypeName:
             /* cope if grammar chooses to believe "variable" is a typename */
             if (pg_strcasecmp(TypeNameToString((TypeName *) def->arg),
                               "variable") == 0)
                 return -1;      /* variable length */
             break;
         case T_List:
             /* must be an operator name */
             break;
         default:
             elog(ERROR, "unrecognized node type: %d", (int) nodeTag(def->arg));
     }
     ereport(ERROR,
             (errcode(ERRCODE_SYNTAX_ERROR),
              errmsg("invalid argument for %s: \"%s\"",
                     def->defname, defGetString(def))));
     return 0;                   /* keep compiler quiet */
 }

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

Referenced by DefineType().

◆ defGetTypeName()

TypeName* defGetTypeName ( DefElem * def )

Definition at line 284 of file define.c.

 {
     if (def->arg == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_SYNTAX_ERROR),
                  errmsg("%s requires a parameter",
                         def->defname)));
     switch (nodeTag(def->arg))
     {
         case T_TypeName:
             return (TypeName *) def->arg;
         case T_String:
             /* Allow quoted typename for backwards compatibility */
             return makeTypeNameFromNameList(list_make1(def->arg));
         default:
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("argument of %s must be a type name",
                             def->defname)));
     }
     return NULL;                /* keep compiler quiet */
 }

References DefElem::arg, DefElem::defname, ereport, errcode(), errmsg(), ERROR, list_make1, makeTypeNameFromNameList(), and nodeTag.

Referenced by DefineAggregate(), DefineOperator(), DefineRange(), DefineType(), and init_params().

◆ DefineAggregate()

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

Definition at line 53 of file aggregatecmds.c.

 {
     char       *aggName;
     Oid         aggNamespace;
     AclResult   aclresult;
     char        aggKind = AGGKIND_NORMAL;
     List       *transfuncName = NIL;
     List       *finalfuncName = NIL;
     List       *combinefuncName = NIL;
     List       *serialfuncName = NIL;
     List       *deserialfuncName = NIL;
     List       *mtransfuncName = NIL;
     List       *minvtransfuncName = NIL;
     List       *mfinalfuncName = NIL;
     bool        finalfuncExtraArgs = false;
     bool        mfinalfuncExtraArgs = false;
     char        finalfuncModify = 0;
     char        mfinalfuncModify = 0;
     List       *sortoperatorName = NIL;
     TypeName   *baseType = NULL;
     TypeName   *transType = NULL;
     TypeName   *mtransType = NULL;
     int32       transSpace = 0;
     int32       mtransSpace = 0;
     char       *initval = NULL;
     char       *minitval = NULL;
     char       *parallel = NULL;
     int         numArgs;
     int         numDirectArgs = 0;
     oidvector  *parameterTypes;
     ArrayType  *allParameterTypes;
     ArrayType  *parameterModes;
     ArrayType  *parameterNames;
     List       *parameterDefaults;
     Oid         variadicArgType;
     Oid         transTypeId;
     Oid         mtransTypeId = InvalidOid;
     char        transTypeType;
     char        mtransTypeType = 0;
     char        proparallel = PROPARALLEL_UNSAFE;
     ListCell   *pl;
  
     /* Convert list of names to a name and namespace */
     aggNamespace = QualifiedNameGetCreationNamespace(name, &aggName);
  
     /* Check we have creation rights in target namespace */
     aclresult = object_aclcheck(NamespaceRelationId, aggNamespace, GetUserId(), ACL_CREATE);
     if (aclresult != ACLCHECK_OK)
         aclcheck_error(aclresult, OBJECT_SCHEMA,
                        get_namespace_name(aggNamespace));
  
     /* Deconstruct the output of the aggr_args grammar production */
     if (!oldstyle)
     {
         Assert(list_length(args) == 2);
         numDirectArgs = intVal(lsecond(args));
         if (numDirectArgs >= 0)
             aggKind = AGGKIND_ORDERED_SET;
         else
             numDirectArgs = 0;
         args = linitial_node(List, args);
     }
  
     /* Examine aggregate's definition clauses */
     foreach(pl, parameters)
     {
         DefElem    *defel = lfirst_node(DefElem, pl);
  
         /*
          * sfunc1, stype1, and initcond1 are accepted as obsolete spellings
          * for sfunc, stype, initcond.
          */
         if (strcmp(defel->defname, "sfunc") == 0)
             transfuncName = defGetQualifiedName(defel);
         else if (strcmp(defel->defname, "sfunc1") == 0)
             transfuncName = defGetQualifiedName(defel);
         else if (strcmp(defel->defname, "finalfunc") == 0)
             finalfuncName = defGetQualifiedName(defel);
         else if (strcmp(defel->defname, "combinefunc") == 0)
             combinefuncName = defGetQualifiedName(defel);
         else if (strcmp(defel->defname, "serialfunc") == 0)
             serialfuncName = defGetQualifiedName(defel);
         else if (strcmp(defel->defname, "deserialfunc") == 0)
             deserialfuncName = defGetQualifiedName(defel);
         else if (strcmp(defel->defname, "msfunc") == 0)
             mtransfuncName = defGetQualifiedName(defel);
         else if (strcmp(defel->defname, "minvfunc") == 0)
             minvtransfuncName = defGetQualifiedName(defel);
         else if (strcmp(defel->defname, "mfinalfunc") == 0)
             mfinalfuncName = defGetQualifiedName(defel);
         else if (strcmp(defel->defname, "finalfunc_extra") == 0)
             finalfuncExtraArgs = defGetBoolean(defel);
         else if (strcmp(defel->defname, "mfinalfunc_extra") == 0)
             mfinalfuncExtraArgs = defGetBoolean(defel);
         else if (strcmp(defel->defname, "finalfunc_modify") == 0)
             finalfuncModify = extractModify(defel);
         else if (strcmp(defel->defname, "mfinalfunc_modify") == 0)
             mfinalfuncModify = extractModify(defel);
         else if (strcmp(defel->defname, "sortop") == 0)
             sortoperatorName = defGetQualifiedName(defel);
         else if (strcmp(defel->defname, "basetype") == 0)
             baseType = defGetTypeName(defel);
         else if (strcmp(defel->defname, "hypothetical") == 0)
         {
             if (defGetBoolean(defel))
             {
                 if (aggKind == AGGKIND_NORMAL)
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                              errmsg("only ordered-set aggregates can be hypothetical")));
                 aggKind = AGGKIND_HYPOTHETICAL;
             }
         }
         else if (strcmp(defel->defname, "stype") == 0)
             transType = defGetTypeName(defel);
         else if (strcmp(defel->defname, "stype1") == 0)
             transType = defGetTypeName(defel);
         else if (strcmp(defel->defname, "sspace") == 0)
             transSpace = defGetInt32(defel);
         else if (strcmp(defel->defname, "mstype") == 0)
             mtransType = defGetTypeName(defel);
         else if (strcmp(defel->defname, "msspace") == 0)
             mtransSpace = defGetInt32(defel);
         else if (strcmp(defel->defname, "initcond") == 0)
             initval = defGetString(defel);
         else if (strcmp(defel->defname, "initcond1") == 0)
             initval = defGetString(defel);
         else if (strcmp(defel->defname, "minitcond") == 0)
             minitval = defGetString(defel);
         else if (strcmp(defel->defname, "parallel") == 0)
             parallel = defGetString(defel);
         else
             ereport(WARNING,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("aggregate attribute \"%s\" not recognized",
                             defel->defname)));
     }
  
     /*
      * make sure we have our required definitions
      */
     if (transType == NULL)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                  errmsg("aggregate stype must be specified")));
     if (transfuncName == NIL)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                  errmsg("aggregate sfunc must be specified")));
  
     /*
      * if mtransType is given, mtransfuncName and minvtransfuncName must be as
      * well; if not, then none of the moving-aggregate options should have
      * been given.
      */
     if (mtransType != NULL)
     {
         if (mtransfuncName == NIL)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("aggregate msfunc must be specified when mstype is specified")));
         if (minvtransfuncName == NIL)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("aggregate minvfunc must be specified when mstype is specified")));
     }
     else
     {
         if (mtransfuncName != NIL)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("aggregate msfunc must not be specified without mstype")));
         if (minvtransfuncName != NIL)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("aggregate minvfunc must not be specified without mstype")));
         if (mfinalfuncName != NIL)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("aggregate mfinalfunc must not be specified without mstype")));
         if (mtransSpace != 0)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("aggregate msspace must not be specified without mstype")));
         if (minitval != NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("aggregate minitcond must not be specified without mstype")));
     }
  
     /*
      * Default values for modify flags can only be determined once we know the
      * aggKind.
      */
     if (finalfuncModify == 0)
         finalfuncModify = (aggKind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
     if (mfinalfuncModify == 0)
         mfinalfuncModify = (aggKind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
  
     /*
      * look up the aggregate's input datatype(s).
      */
     if (oldstyle)
     {
         /*
          * Old style: use basetype parameter.  This supports aggregates of
          * zero or one input, with input type ANY meaning zero inputs.
          *
          * Historically we allowed the command to look like basetype = 'ANY'
          * so we must do a case-insensitive comparison for the name ANY. Ugh.
          */
         Oid         aggArgTypes[1];
  
         if (baseType == NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("aggregate input type must be specified")));
  
         if (pg_strcasecmp(TypeNameToString(baseType), "ANY") == 0)
         {
             numArgs = 0;
             aggArgTypes[0] = InvalidOid;
         }
         else
         {
             numArgs = 1;
             aggArgTypes[0] = typenameTypeId(NULL, baseType);
         }
         parameterTypes = buildoidvector(aggArgTypes, numArgs);
         allParameterTypes = NULL;
         parameterModes = NULL;
         parameterNames = NULL;
         parameterDefaults = NIL;
         variadicArgType = InvalidOid;
     }
     else
     {
         /*
          * New style: args is a list of FunctionParameters (possibly zero of
          * 'em).  We share functioncmds.c's code for processing them.
          */
         Oid         requiredResultType;
  
         if (baseType != NULL)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("basetype is redundant with aggregate input type specification")));
  
         numArgs = list_length(args);
         interpret_function_parameter_list(pstate,
                                           args,
                                           InvalidOid,
                                           OBJECT_AGGREGATE,
                                           &parameterTypes,
                                           NULL,
                                           &allParameterTypes,
                                           &parameterModes,
                                           &parameterNames,
                                           NULL,
                                           &parameterDefaults,
                                           &variadicArgType,
                                           &requiredResultType);
         /* Parameter defaults are not currently allowed by the grammar */
         Assert(parameterDefaults == NIL);
         /* There shouldn't have been any OUT parameters, either */
         Assert(requiredResultType == InvalidOid);
     }
  
     /*
      * look up the aggregate's transtype.
      *
      * transtype can't be a pseudo-type, since we need to be able to store
      * values of the transtype.  However, we can allow polymorphic transtype
      * in some cases (AggregateCreate will check).  Also, we allow "internal"
      * for functions that want to pass pointers to private data structures;
      * but allow that only to superusers, since you could crash the system (or
      * worse) by connecting up incompatible internal-using functions in an
      * aggregate.
      */
     transTypeId = typenameTypeId(NULL, transType);
     transTypeType = get_typtype(transTypeId);
     if (transTypeType == TYPTYPE_PSEUDO &&
         !IsPolymorphicType(transTypeId))
     {
         if (transTypeId == INTERNALOID && superuser())
              /* okay */ ;
         else
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("aggregate transition data type cannot be %s",
                             format_type_be(transTypeId))));
     }
  
     if (serialfuncName && deserialfuncName)
     {
         /*
          * Serialization is only needed/allowed for transtype INTERNAL.
          */
         if (transTypeId != INTERNALOID)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                      errmsg("serialization functions may be specified only when the aggregate transition data type is %s",
                             format_type_be(INTERNALOID))));
     }
     else if (serialfuncName || deserialfuncName)
     {
         /*
          * Cannot specify one function without the other.
          */
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                  errmsg("must specify both or neither of serialization and deserialization functions")));
     }
  
     /*
      * If a moving-aggregate transtype is specified, look that up.  Same
      * restrictions as for transtype.
      */
     if (mtransType)
     {
         mtransTypeId = typenameTypeId(NULL, mtransType);
         mtransTypeType = get_typtype(mtransTypeId);
         if (mtransTypeType == TYPTYPE_PSEUDO &&
             !IsPolymorphicType(mtransTypeId))
         {
             if (mtransTypeId == INTERNALOID && superuser())
                  /* okay */ ;
             else
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                          errmsg("aggregate transition data type cannot be %s",
                                 format_type_be(mtransTypeId))));
         }
     }
  
     /*
      * If we have an initval, and it's not for a pseudotype (particularly a
      * polymorphic type), make sure it's acceptable to the type's input
      * function.  We will store the initval as text, because the input
      * function isn't necessarily immutable (consider "now" for timestamp),
      * and we want to use the runtime not creation-time interpretation of the
      * value.  However, if it's an incorrect value it seems much more
      * user-friendly to complain at CREATE AGGREGATE time.
      */
     if (initval && transTypeType != TYPTYPE_PSEUDO)
     {
         Oid         typinput,
                     typioparam;
  
         getTypeInputInfo(transTypeId, &typinput, &typioparam);
         (void) OidInputFunctionCall(typinput, initval, typioparam, -1);
     }
  
     /*
      * Likewise for moving-aggregate initval.
      */
     if (minitval && mtransTypeType != TYPTYPE_PSEUDO)
     {
         Oid         typinput,
                     typioparam;
  
         getTypeInputInfo(mtransTypeId, &typinput, &typioparam);
         (void) OidInputFunctionCall(typinput, minitval, typioparam, -1);
     }
  
     if (parallel)
     {
         if (strcmp(parallel, "safe") == 0)
             proparallel = PROPARALLEL_SAFE;
         else if (strcmp(parallel, "restricted") == 0)
             proparallel = PROPARALLEL_RESTRICTED;
         else if (strcmp(parallel, "unsafe") == 0)
             proparallel = PROPARALLEL_UNSAFE;
         else
             ereport(ERROR,
                     (errcode(ERRCODE_SYNTAX_ERROR),
                      errmsg("parameter \"parallel\" must be SAFE, RESTRICTED, or UNSAFE")));
     }
  
     /*
      * Most of the argument-checking is done inside of AggregateCreate
      */
     return AggregateCreate(aggName, /* aggregate name */
                            aggNamespace,    /* namespace */
                            replace,
                            aggKind,
                            numArgs,
                            numDirectArgs,
                            parameterTypes,
                            PointerGetDatum(allParameterTypes),
                            PointerGetDatum(parameterModes),
                            PointerGetDatum(parameterNames),
                            parameterDefaults,
                            variadicArgType,
                            transfuncName,   /* step function name */
                            finalfuncName,   /* final function name */
                            combinefuncName, /* combine function name */
                            serialfuncName,  /* serial function name */
                            deserialfuncName,    /* deserial function name */
                            mtransfuncName,  /* fwd trans function name */
                            minvtransfuncName,   /* inv trans function name */
                            mfinalfuncName,  /* final function name */
                            finalfuncExtraArgs,
                            mfinalfuncExtraArgs,
                            finalfuncModify,
                            mfinalfuncModify,
                            sortoperatorName,    /* sort operator name */
                            transTypeId, /* transition data type */
                            transSpace,  /* transition space */
                            mtransTypeId,    /* transition data type */
                            mtransSpace, /* transition space */
                            initval, /* initial condition */
                            minitval,    /* initial condition */
                            proparallel);    /* parallel safe? */
 }

References ACL_CREATE, aclcheck_error(), ACLCHECK_OK, AggregateCreate(), generate_unaccent_rules::args, Assert, buildoidvector(), defGetBoolean(), defGetInt32(), defGetQualifiedName(), defGetString(), defGetTypeName(), DefElem::defname, ereport, errcode(), errmsg(), ERROR, extractModify(), format_type_be(), get_namespace_name(), get_typtype(), getTypeInputInfo(), GetUserId(), interpret_function_parameter_list(), intVal, InvalidOid, lfirst_node, linitial_node, list_length(), lsecond, name, NIL, object_aclcheck(), OBJECT_AGGREGATE, OBJECT_SCHEMA, OidInputFunctionCall(), pg_strcasecmp(), PointerGetDatum(), QualifiedNameGetCreationNamespace(), superuser(), TypeNameToString(), typenameTypeId(), and WARNING.

Referenced by ProcessUtilitySlow().

◆ DefineIndex()

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

Definition at line 543 of file indexcmds.c.

 {
     bool        concurrent;
     char       *indexRelationName;
     char       *accessMethodName;
     Oid        *typeIds;
     Oid        *collationIds;
     Oid        *opclassIds;
     Datum      *opclassOptions;
     Oid         accessMethodId;
     Oid         namespaceId;
     Oid         tablespaceId;
     Oid         createdConstraintId = InvalidOid;
     List       *indexColNames;
     List       *allIndexParams;
     Relation    rel;
     HeapTuple   tuple;
     Form_pg_am  accessMethodForm;
     IndexAmRoutine *amRoutine;
     bool        amcanorder;
     bool        amissummarizing;
     amoptions_function amoptions;
     bool        exclusion;
     bool        partitioned;
     bool        safe_index;
     Datum       reloptions;
     int16      *coloptions;
     IndexInfo  *indexInfo;
     bits16      flags;
     bits16      constr_flags;
     int         numberOfAttributes;
     int         numberOfKeyAttributes;
     TransactionId limitXmin;
     ObjectAddress address;
     LockRelId   heaprelid;
     LOCKTAG     heaplocktag;
     LOCKMODE    lockmode;
     Snapshot    snapshot;
     Oid         root_save_userid;
     int         root_save_sec_context;
     int         root_save_nestlevel;
  
     root_save_nestlevel = NewGUCNestLevel();
  
     RestrictSearchPath();
  
     /*
      * Some callers need us to run with an empty default_tablespace; this is a
      * necessary hack to be able to reproduce catalog state accurately when
      * recreating indexes after table-rewriting ALTER TABLE.
      */
     if (stmt->reset_default_tblspc)
         (void) set_config_option("default_tablespace", "",
                                  PGC_USERSET, PGC_S_SESSION,
                                  GUC_ACTION_SAVE, true, 0, false);
  
     /*
      * Force non-concurrent build on temporary relations, even if CONCURRENTLY
      * was requested.  Other backends can't access a temporary relation, so
      * there's no harm in grabbing a stronger lock, and a non-concurrent DROP
      * is more efficient.  Do this before any use of the concurrent option is
      * done.
      */
     if (stmt->concurrent && get_rel_persistence(tableId) != RELPERSISTENCE_TEMP)
         concurrent = true;
     else
         concurrent = false;
  
     /*
      * Start progress report.  If we're building a partition, this was already
      * done.
      */
     if (!OidIsValid(parentIndexId))
     {
         pgstat_progress_start_command(PROGRESS_COMMAND_CREATE_INDEX, tableId);
         pgstat_progress_update_param(PROGRESS_CREATEIDX_COMMAND,
                                      concurrent ?
                                      PROGRESS_CREATEIDX_COMMAND_CREATE_CONCURRENTLY :
                                      PROGRESS_CREATEIDX_COMMAND_CREATE);
     }
  
     /*
      * No index OID to report yet
      */
     pgstat_progress_update_param(PROGRESS_CREATEIDX_INDEX_OID,
                                  InvalidOid);
  
     /*
      * count key attributes in index
      */
     numberOfKeyAttributes = list_length(stmt->indexParams);
  
     /*
      * Calculate the new list of index columns including both key columns and
      * INCLUDE columns.  Later we can determine which of these are key
      * columns, and which are just part of the INCLUDE list by checking the
      * list position.  A list item in a position less than ii_NumIndexKeyAttrs
      * is part of the key columns, and anything equal to and over is part of
      * the INCLUDE columns.
      */
     allIndexParams = list_concat_copy(stmt->indexParams,
                                       stmt->indexIncludingParams);
     numberOfAttributes = list_length(allIndexParams);
  
     if (numberOfKeyAttributes <= 0)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                  errmsg("must specify at least one column")));
     if (numberOfAttributes > INDEX_MAX_KEYS)
         ereport(ERROR,
                 (errcode(ERRCODE_TOO_MANY_COLUMNS),
                  errmsg("cannot use more than %d columns in an index",
                         INDEX_MAX_KEYS)));
  
     /*
      * Only SELECT ... FOR UPDATE/SHARE are allowed while doing a standard
      * index build; but for concurrent builds we allow INSERT/UPDATE/DELETE
      * (but not VACUUM).
      *
      * NB: Caller is responsible for making sure that tableId refers to the
      * relation on which the index should be built; except in bootstrap mode,
      * this will typically require the caller to have already locked the
      * relation.  To avoid lock upgrade hazards, that lock should be at least
      * as strong as the one we take here.
      *
      * NB: If the lock strength here ever changes, code that is run by
      * parallel workers under the control of certain particular ambuild
      * functions will need to be updated, too.
      */
     lockmode = concurrent ? ShareUpdateExclusiveLock : ShareLock;
     rel = table_open(tableId, lockmode);
  
     /*
      * Switch to the table owner's userid, so that any index functions are run
      * as that user.  Also lock down security-restricted operations.  We
      * already arranged to make GUC variable changes local to this command.
      */
     GetUserIdAndSecContext(&root_save_userid, &root_save_sec_context);
     SetUserIdAndSecContext(rel->rd_rel->relowner,
                            root_save_sec_context | SECURITY_RESTRICTED_OPERATION);
  
     namespaceId = RelationGetNamespace(rel);
  
     /*
      * It has exclusion constraint behavior if it's an EXCLUDE constraint or a

Functions

Function Documentation

◆ AlterForeignDataWrapper()

◆ AlterForeignDataWrapperOwner()

◆ AlterForeignDataWrapperOwner_oid()

◆ AlterForeignServer()

◆ AlterForeignServerOwner()

◆ AlterForeignServerOwner_oid()

◆ AlterFunction()

◆ AlterOperator()

◆ AlterOpFamily()

◆ AlterStatistics()

◆ AlterTSConfiguration()

◆ AlterTSDictionary()

◆ AlterUserMapping()

◆ CallStmtResultDesc()

◆ CheckIndexCompatible()

◆ ChooseRelationName()

◆ CreateAccessMethod()

◆ CreateCast()

◆ CreateForeignDataWrapper()

◆ CreateForeignServer()

◆ CreateForeignTable()

◆ CreateFunction()

◆ CreateStatistics()

◆ CreateTransform()

◆ CreateUserMapping()

◆ defGetBoolean()

◆ defGetInt32()

◆ defGetInt64()

◆ defGetNumeric()

◆ defGetObjectId()

◆ defGetQualifiedName()

◆ defGetString()

◆ defGetStringList()

◆ defGetTypeLength()

◆ defGetTypeName()

◆ DefineAggregate()

◆ DefineIndex()