defrem.h File Reference

#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)
Oid	GetDefaultOpClass (Oid type_id, Oid am_id)
Oid	ResolveOpClass (const List *opclass, Oid attrType, const char *accessMethodName, Oid accessMethodId)
ObjectAddress	CreateFunction (ParseState *pstate, CreateFunctionStmt *stmt)
void	RemoveFunctionById (Oid funcOid)
ObjectAddress	AlterFunction (ParseState *pstate, AlterFunctionStmt *stmt)
ObjectAddress	CreateCast (CreateCastStmt *stmt)
ObjectAddress	CreateTransform (CreateTransformStmt *stmt)
void	IsThereFunctionInNamespace (const char *proname, int pronargs, oidvector *proargtypes, Oid nspOid)
void	ExecuteDoStmt (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, FOREIGNDATAWRAPPERNAME, FOREIGNDATAWRAPPEROID, 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, FOREIGNDATAWRAPPERNAME, 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, FOREIGNDATAWRAPPEROID, heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum(), RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by shdepReassignOwned().

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, FOREIGNSERVERNAME, FOREIGNSERVEROID, 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, FOREIGNSERVERNAME, 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, FOREIGNSERVEROID, heap_freetuple(), HeapTupleIsValid, ObjectIdGetDatum(), RowExclusiveLock, SearchSysCacheCopy1, table_close(), and table_open().

Referenced by shdepReassignOwned().

AlterFunction()

ObjectAddress AlterFunction	(	ParseState *	pstate,
		AlterFunctionStmt *	stmt
	)

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

References aclcheck_error(), ACLCHECK_NOT_OWNER, DefElem::arg, CatalogTupleUpdate(), defGetQualifiedName(), DefElem::defname, elog(), ereport, errcode(), errmsg(), ERROR, GETSTRUCT, GetUserId(), heap_modify_tuple(), HeapTupleIsValid, i, InvalidOid, InvokeObjectPostAlterHook, lfirst, LookupOperWithArgs(), makeOperatorDependencies(), NameStr, NIL, NoLock, OBJECT_OPERATOR, object_ownercheck(), ObjectIdGetDatum(), OidIsValid, OPEROID, RelationGetDescr, RowExclusiveLock, SearchSysCacheCopy1, stmt, HeapTupleData::t_self, table_close(), table_open(), ValidateJoinEstimator(), 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(), AMNAME, 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 602 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 = stmt->stxstattarget;
 
    /* Limit statistics target to a sane range */
    if (newtarget < -1)
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("statistics target %d is too low",
                        newtarget)));
    }
    else if (newtarget > 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;
    repl_val[Anum_pg_statistic_ext_stxstattarget - 1] = Int16GetDatum(newtarget);
 
    newtup = heap_modify_tuple(oldtup, RelationGetDescr(rel),
                               repl_val, repl_null, repl_repl);
 
    /* Update system catalog. */
    CatalogTupleUpdate(rel, &newtup->t_self, newtup);
 
    InvokeObjectPostAlterHook(StatisticExtRelationId, stxoid, 0);
 
    ObjectAddressSet(address, StatisticExtRelationId, stxoid);
 
    /*
     * NOTE: because we only support altering the statistics target, not the
     * other fields, there is no need to update dependencies.
     */
 
    heap_freetuple(newtup);
    ReleaseSysCache(oldtup);
 
    table_close(rel, RowExclusiveLock);
 
    return address;
}

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(), InvalidObjectAddress, InvokeObjectPostAlterHook, MAX_STATISTICS_TARGET, NameListToString(), NOTICE, object_ownercheck(), OBJECT_STATISTIC_EXT, ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), STATEXTOID, stmt, HeapTupleData::t_self, table_close(), table_open(), and WARNING.

Referenced by ProcessUtilitySlow().

AlterTSConfiguration()

ObjectAddress AlterTSConfiguration

(

AlterTSConfigurationStmt *

stmt

)

Definition at line 1150 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 487 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(), TSDICTOID, 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(), user_mapping_ddl_aclcheck(), and USERMAPPINGOID.

Referenced by ProcessUtilitySlow().

CallStmtResultDesc()

TupleDesc CallStmtResultDesc

(

CallStmt *

stmt

)

Definition at line 2357 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);
 
    return tupdesc;
}

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

Referenced by UtilityTupleDescriptor().

CheckIndexCompatible()

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

Definition at line 171 of file indexcmds.c.

{
    bool        isconstraint;
    Oid        *typeIds;
    Oid        *collationIds;
    Oid        *opclassIds;
    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);
    typeIds = palloc_array(Oid, numberOfAttributes);
    collationIds = palloc_array(Oid, numberOfAttributes);
    opclassIds = palloc_array(Oid, numberOfAttributes);
    coloptions = palloc_array(int16, numberOfAttributes);
    ComputeIndexAttrs(indexInfo,
                      typeIds, collationIds, opclassIds,
                      coloptions, attributeList,
                      exclusionOpNames, relationId,
                      accessMethodName, accessMethodId,
                      amcanorder, isconstraint, 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      *opclassOptions = RelationGetIndexRawAttOptions(irel);
 
        ret = CompareOpclassOptions(opclassOptions,
                                    indexInfo->ii_OpclassOptions, old_natts);
 
        if (opclassOptions)
            pfree(opclassOptions);
    }
 
    /* Any change in exclusion operator selections breaks compatibility. */
    if (ret && indexInfo->ii_ExclusionOps != NULL)
    {
        Oid        *old_operators,
                   *old_procs;
        uint16     *old_strats;
 
        RelationGetExclusionInfo(irel, &old_operators, &old_procs, &old_strats);
        ret = memcmp(old_operators, indexInfo->ii_ExclusionOps,
                     old_natts * sizeof(Oid)) == 0;
 
        /* Require an exact input type match for polymorphic operators. */
        if (ret)
        {
            for (i = 0; i < old_natts && ret; i++)
            {
                Oid         left,
                            right;
 
                op_input_types(indexInfo->ii_ExclusionOps[i], &left, &right);
                if ((IsPolymorphicType(left) || IsPolymorphicType(right)) &&
                    TupleDescAttr(irel->rd_att, i)->atttypid != typeIds[i])
                {
                    ret = false;
                    break;
                }
            }
        }
    }
 
    index_close(irel, NoLock);
    return ret;
}

References AccessShareLock, IndexAmRoutine::amcanorder, AMNAME, IndexAmRoutine::amsummarizing, Assert(), CompareOpclassOptions(), ComputeIndexAttrs(), DatumGetPointer(), elog(), ereport, errcode(), errmsg(), ERROR, get_opclass_input_type(), GetIndexAmRoutine(), GETSTRUCT, heap_attisnull(), HeapTupleIsValid, i, IndexInfo::ii_ExclusionOps, IndexInfo::ii_OpclassOptions, index_close(), INDEX_MAX_KEYS, index_open(), IndexGetRelation(), INDEXRELID, InvalidOid, list_length(), makeIndexInfo(), NIL, NoLock, ObjectIdGetDatum(), op_input_types(), palloc_array, pfree(), PointerGetDatum(), RelationData::rd_att, RelationGetExclusionInfo(), RelationGetIndexRawAttOptions(), 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 2505 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 AMNAME, 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 1526 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, enum and array types are never binary-
         * compatible with each other.  They all have OIDs embedded in them.
         *
         * Theoretically you could build a user-defined base type that is
         * binary-compatible with a composite, enum, or array type.  But we
         * disallow that too, as in practice such a cast is surely a mistake.
         * You can always work around that by writing a cast function.
         */
        if (sourcetyptype == TYPTYPE_COMPOSITE ||
            targettyptype == TYPTYPE_COMPOSITE)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("composite data types are not binary-compatible")));
 
        if (sourcetyptype == TYPTYPE_ENUM ||
            targettyptype == TYPTYPE_ENUM)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("enum data types are not binary-compatible")));
 
        if (OidIsValid(get_element_type(sourcetypeid)) ||
            OidIsValid(get_element_type(targettypeid)))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("array data types are not binary-compatible")));
 
        /*
         * We also disallow creating binary-compatibility casts involving
         * domains.  Casting from a domain to its base type is already
         * allowed, and casting the other way ought to go through domain
         * coercion to permit constraint checking.  Again, if you're intent on
         * having your own semantics for that, create a no-op cast function.
         *
         * NOTE: if we were to relax this, the above checks for composites
         * etc. would have to be modified to look through domains to their
         * base types.
         */
        if (sourcetyptype == TYPTYPE_DOMAIN ||
            targettyptype == TYPTYPE_DOMAIN)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("domain data types must not be marked binary-compatible")));
    }
 
    /*
     * Allow source and target types to be same only for length coercion
     * functions.  We assume a multi-arg function does length coercion.
     */
    if (sourcetypeid == targettypeid && nargs < 2)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("source data type and target data type are the same")));
 
    /* convert CoercionContext enum to char value for castcontext */
    switch (stmt->context)
    {
        case COERCION_IMPLICIT:
            castcontext = COERCION_CODE_IMPLICIT;
            break;
        case COERCION_ASSIGNMENT:
            castcontext = COERCION_CODE_ASSIGNMENT;
            break;
            /* COERCION_PLPGSQL is intentionally not covered here */
        case COERCION_EXPLICIT:
            castcontext = COERCION_CODE_EXPLICIT;
            break;
        default:
            elog(ERROR, "unrecognized CoercionContext: %d", stmt->context);
            castcontext = 0;    /* keep compiler quiet */
            break;
    }
 
    myself = CastCreate(sourcetypeid, targettypeid, funcid, 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, PROCOID, 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 1016 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, LANGNAME, 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 65 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_stxstattarget - 1] = Int16GetDatum(-1);
    values[Anum_pg_statistic_ext_stxowner - 1] = ObjectIdGetDatum(stxowner);
    values[Anum_pg_statistic_ext_stxkeys - 1] = PointerGetDatum(stxkeys);
    values[Anum_pg_statistic_ext_stxkind - 1] = PointerGetDatum(stxkind);
 
    values[Anum_pg_statistic_ext_stxexprs - 1] = exprsDatum;
    if (exprsDatum == (Datum) 0)
        nulls[Anum_pg_statistic_ext_stxexprs - 1] = true;
 
    /* insert it into pg_statistic_ext */
    htup = heap_form_tuple(statrel->rd_att, values, nulls);
    CatalogTupleInsert(statrel, htup);
    heap_freetuple(htup);
 
    relation_close(statrel, RowExclusiveLock);
 
    /*
     * 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(), Int16GetDatum(), 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, STATEXTNAMENSP, 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 1806 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, PROCOID, record_object_address_dependencies(), recordDependencyOnCurrentExtension(), RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), SearchSysCache2(), stmt, HeapTupleData::t_self, table_close(), table_open(), TRFTYPELANG, 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 108 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(), 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 163 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 187 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 init_params(), and parse_basebackup_options().

defGetNumeric()

double defGetNumeric

(

DefElem *

def

)

Definition at line 82 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 220 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 253 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 49 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(), 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 357 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 generate_unaccent_rules::str.

defGetTypeLength()

int defGetTypeLength

(

DefElem *

def

)

Definition at line 313 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 285 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 57 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 525 of file indexcmds.c.

{
    bool        concurrent;
    char       *indexRelationName;
    char       *accessMethodName;
    Oid        *typeIds;
    Oid        *collationIds;
    Oid        *opclassIds;
    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        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();
 
    /*
     * 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);
 
    /* Ensure that it makes sense to index this kind of relation */
    switch (rel->rd_rel->relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_MATVIEW:
        case RELKIND_PARTITIONED_TABLE:
            /* OK */
            break;
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot create index on relation \"%s\"",
                            RelationGetRelationName(rel)),
                     errdetail_relkind_not_supported(rel->rd_rel->relkind)));
            break;
    }
 
    /*
     * Establish behavior for partitioned tables, and verify sanity of
     * parameters.
     *
     * We do not build an actual index in this case; we only create a few
     * catalog entries.  The actual indexes are built by recursing for each
     * partition.
     */
    partitioned = rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE;
    if (partitioned)
    {
        /*
         * Note: we check 'stmt->concurrent' rather than 'concurrent', so that
         * the error is thrown also for temporary tables.  Seems better to be
         * consistent, even though we could do it on temporary table because
         * we're not actually doing it concurrently.
         */
        if (stmt->concurrent)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot create index on partitioned table \"%s\" concurrently",
                            RelationGetRelationName(rel))));
    }
 
    /*
     * Don't try to CREATE INDEX on temp tables of other backends.
     */
    if (RELATION_IS_OTHER_TEMP(rel))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot create indexes on temporary tables of other sessions")));
 
    /*
     * Unless our caller vouches for having checked this already, insist that
     * the table not be in use by our own session, either.  Otherwise we might
     * fail to make entries in the new index (for instance, if an INSERT or
     * UPDATE is in progress and has already made its list of target indexes).
     */
    if (check_not_in_use)
        CheckTableNotInUse(rel, "CREATE INDEX");
 
    /*
     * Verify we (still) have CREATE rights in the rel's namespace.
     * (Presumably we did when the rel was created, but maybe not anymore.)
     * Skip check if caller doesn't want it.  Also skip check if
     * bootstrapping, since permissions machinery may not be working yet.
     */
    if (check_rights && !IsBootstrapProcessingMode())
    {
        AclResult   aclresult;
 
        aclresult = object_aclcheck(NamespaceRelationId, namespaceId, root_save_userid,
                                    ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_SCHEMA,
                           get_namespace_name(namespaceId));
    }
 
    /*
     * Select tablespace to use.  If not specified, use default tablespace
     * (which may in turn default to database's default).
     */
    if (stmt->tableSpace)
    {
        tablespaceId = get_tablespace_oid(stmt->tableSpace, false);
        if (partitioned && tablespaceId == MyDatabaseTableSpace)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot specify default tablespace for partitioned relations")));
    }
    else
    {
        tablespaceId = GetDefaultTablespace(rel->rd_rel->relpersistence,
                                            partitioned);
        /* note InvalidOid is OK in this case */
    }
 
    /* Check tablespace permissions */
    if (check_rights &&
        OidIsValid(tablespaceId) && tablespaceId != MyDatabaseTableSpace)
    {
        AclResult   aclresult;
 
        aclresult = object_aclcheck(TableSpaceRelationId, tablespaceId, root_save_userid,
                                    ACL_CREATE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_TABLESPACE,
                           get_tablespace_name(tablespaceId));
    }
 
    /*
     * Force shared indexes into the pg_global tablespace.  This is a bit of a
     * hack but seems simpler than marking them in the BKI commands.  On the
     * other hand, if it's not shared, don't allow it to be placed there.
     */
    if (rel->rd_rel->relisshared)
        tablespaceId = GLOBALTABLESPACE_OID;
    else if