defrem.h File Reference

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

Include dependency graph for defrem.h:

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

Go to the source code of this file.

Functions
void	RemoveObjects (DropStmt *stmt)
ObjectAddress	DefineIndex (Oid relationId, IndexStmt *stmt, Oid indexRelationId, Oid parentIndexId, Oid parentConstraintId, bool is_alter_table, bool check_rights, bool check_not_in_use, bool skip_build, bool quiet)
void	ReindexIndex (RangeVar *indexRelation, int options)
Oid	ReindexTable (RangeVar *relation, int options)
void	ReindexMultipleTables (const char *objectName, ReindexObjectType objectKind, int options)
char *	makeObjectName (const char *name1, const char *name2, const char *label)
char *	ChooseRelationName (const char *name1, const char *name2, const char *label, Oid namespaceid)
bool	CheckIndexCompatible (Oid oldId, const char *accessMethodName, List *attributeList, List *exclusionOpNames)
Oid	GetDefaultOpClass (Oid type_id, Oid am_id)
Oid	ResolveOpClass (List *opclass, Oid attrType, const char *accessMethodName, Oid accessMethodId)
ObjectAddress	CreateFunction (ParseState *pstate, CreateFunctionStmt *stmt)
void	RemoveFunctionById (Oid funcOid)
void	SetFunctionReturnType (Oid funcOid, Oid newRetType)
void	SetFunctionArgType (Oid funcOid, int argIndex, Oid newArgType)
ObjectAddress	AlterFunction (ParseState *pstate, AlterFunctionStmt *stmt)
ObjectAddress	CreateCast (CreateCastStmt *stmt)
void	DropCastById (Oid castOid)
ObjectAddress	CreateTransform (CreateTransformStmt *stmt)
void	DropTransformById (Oid transformOid)
void	IsThereFunctionInNamespace (const char *proname, int pronargs, oidvector *proargtypes, Oid nspOid)
void	ExecuteDoStmt (DoStmt *stmt, bool atomic)
void	ExecuteCallStmt (CallStmt *stmt, ParamListInfo params, bool atomic, DestReceiver *dest)
Oid	get_cast_oid (Oid sourcetypeid, Oid targettypeid, bool missing_ok)
Oid	get_transform_oid (Oid type_id, Oid lang_id, bool missing_ok)
void	interpret_function_parameter_list (ParseState *pstate, List *parameters, Oid languageOid, ObjectType objtype, oidvector **parameterTypes, ArrayType **allParameterTypes, ArrayType **parameterModes, ArrayType **parameterNames, List **parameterDefaults, Oid *variadicArgType, Oid *requiredResultType)
ObjectAddress	DefineOperator (List *names, List *parameters)
void	RemoveOperatorById (Oid operOid)
ObjectAddress	AlterOperator (AlterOperatorStmt *stmt)
ObjectAddress	CreateStatistics (CreateStatsStmt *stmt)
void	RemoveStatisticsById (Oid statsOid)
void	UpdateStatisticsForTypeChange (Oid statsOid, Oid relationOid, int attnum, Oid oldColumnType, Oid newColumnType)
ObjectAddress	DefineAggregate (ParseState *pstate, List *name, List *args, bool oldstyle, List *parameters)
ObjectAddress	DefineOpClass (CreateOpClassStmt *stmt)
ObjectAddress	DefineOpFamily (CreateOpFamilyStmt *stmt)
Oid	AlterOpFamily (AlterOpFamilyStmt *stmt)
void	RemoveOpClassById (Oid opclassOid)
void	RemoveOpFamilyById (Oid opfamilyOid)
void	RemoveAmOpEntryById (Oid entryOid)
void	RemoveAmProcEntryById (Oid entryOid)
void	IsThereOpClassInNamespace (const char *opcname, Oid opcmethod, Oid opcnamespace)
void	IsThereOpFamilyInNamespace (const char *opfname, Oid opfmethod, Oid opfnamespace)
Oid	get_opclass_oid (Oid amID, List *opclassname, bool missing_ok)
Oid	get_opfamily_oid (Oid amID, List *opfamilyname, bool missing_ok)
ObjectAddress	DefineTSParser (List *names, List *parameters)
void	RemoveTSParserById (Oid prsId)
ObjectAddress	DefineTSDictionary (List *names, List *parameters)
void	RemoveTSDictionaryById (Oid dictId)
ObjectAddress	AlterTSDictionary (AlterTSDictionaryStmt *stmt)
ObjectAddress	DefineTSTemplate (List *names, List *parameters)
void	RemoveTSTemplateById (Oid tmplId)
ObjectAddress	DefineTSConfiguration (List *names, List *parameters, ObjectAddress *copied)
void	RemoveTSConfigurationById (Oid cfgId)
ObjectAddress	AlterTSConfiguration (AlterTSConfigurationStmt *stmt)
text *	serialize_deflist (List *deflist)
List *	deserialize_deflist (Datum txt)
ObjectAddress	AlterForeignServerOwner (const char *name, Oid newOwnerId)
void	AlterForeignServerOwner_oid (Oid, Oid newOwnerId)
ObjectAddress	AlterForeignDataWrapperOwner (const char *name, Oid newOwnerId)
void	AlterForeignDataWrapperOwner_oid (Oid fwdId, Oid newOwnerId)
ObjectAddress	CreateForeignDataWrapper (CreateFdwStmt *stmt)
ObjectAddress	AlterForeignDataWrapper (AlterFdwStmt *stmt)
void	RemoveForeignDataWrapperById (Oid fdwId)
ObjectAddress	CreateForeignServer (CreateForeignServerStmt *stmt)
ObjectAddress	AlterForeignServer (AlterForeignServerStmt *stmt)
void	RemoveForeignServerById (Oid srvId)
ObjectAddress	CreateUserMapping (CreateUserMappingStmt *stmt)
ObjectAddress	AlterUserMapping (AlterUserMappingStmt *stmt)
Oid	RemoveUserMapping (DropUserMappingStmt *stmt)
void	RemoveUserMappingById (Oid umId)
void	CreateForeignTable (CreateForeignTableStmt *stmt, Oid relid)
void	ImportForeignSchema (ImportForeignSchemaStmt *stmt)
Datum	transformGenericOptions (Oid catalogId, Datum oldOptions, List *options, Oid fdwvalidator)
ObjectAddress	CreateAccessMethod (CreateAmStmt *stmt)
void	RemoveAccessMethodById (Oid amOid)
Oid	get_index_am_oid (const char *amname, bool missing_ok)
Oid	get_am_oid (const char *amname, bool missing_ok)
char *	get_am_name (Oid amOid)
char *	defGetString (DefElem *def)
double	defGetNumeric (DefElem *def)
bool	defGetBoolean (DefElem *def)
int32	defGetInt32 (DefElem *def)
int64	defGetInt64 (DefElem *def)
List *	defGetQualifiedName (DefElem *def)
TypeName *	defGetTypeName (DefElem *def)
int	defGetTypeLength (DefElem *def)
List *	defGetStringList (DefElem *def)

Function Documentation

AlterForeignDataWrapper()

ObjectAddress AlterForeignDataWrapper

(

AlterFdwStmt *

stmt

)

Definition at line 673 of file foreigncmds.c.

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

Referenced by ProcessUtilitySlow().

{
    Relation    rel;
    HeapTuple   tp;
    Form_pg_foreign_data_wrapper fdwForm;
    Datum       repl_val[Natts_pg_foreign_data_wrapper];
    bool        repl_null[Natts_pg_foreign_data_wrapper];
    bool        repl_repl[Natts_pg_foreign_data_wrapper];
    Oid         fdwId;
    bool        isnull;
    Datum       datum;
    bool        handler_given;
    bool        validator_given;
    Oid         fdwhandler;
    Oid         fdwvalidator;
    ObjectAddress myself;

    rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);

    /* Must be super user */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to alter foreign-data wrapper \"%s\"",
                        stmt->fdwname),
                 errhint("Must be superuser to alter a foreign-data wrapper.")));

    tp = SearchSysCacheCopy1(FOREIGNDATAWRAPPERNAME,
                             CStringGetDatum(stmt->fdwname));

    if (!HeapTupleIsValid(tp))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("foreign-data wrapper \"%s\" does not exist", stmt->fdwname)));

    fdwForm = (Form_pg_foreign_data_wrapper) GETSTRUCT(tp);
    fdwId = HeapTupleGetOid(tp);

    memset(repl_val, 0, sizeof(repl_val));
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));

    parse_func_options(stmt->func_options,
                       &handler_given, &fdwhandler,
                       &validator_given, &fdwvalidator);

    if (handler_given)
    {
        repl_val[Anum_pg_foreign_data_wrapper_fdwhandler - 1] = ObjectIdGetDatum(fdwhandler);
        repl_repl[Anum_pg_foreign_data_wrapper_fdwhandler - 1] = true;

        /*
         * It could be that the behavior of accessing foreign table changes
         * with the new handler.  Warn about this.
         */
        ereport(WARNING,
                (errmsg("changing the foreign-data wrapper handler can change behavior of existing foreign tables")));
    }

    if (validator_given)
    {
        repl_val[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = ObjectIdGetDatum(fdwvalidator);
        repl_repl[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = true;

        /*
         * It could be that existing options for the FDW or dependent SERVER,
         * USER MAPPING or FOREIGN TABLE objects are no longer valid according
         * to the new validator.  Warn about this.
         */
        if (OidIsValid(fdwvalidator))
            ereport(WARNING,
                    (errmsg("changing the foreign-data wrapper validator can cause "
                            "the options for dependent objects to become invalid")));
    }
    else
    {
        /*
         * Validator is not changed, but we need it for validating options.
         */
        fdwvalidator = fdwForm->fdwvalidator;
    }

    /*
     * If options specified, validate and update.
     */
    if (stmt->options)
    {
        /* Extract the current options */
        datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,
                                tp,
                                Anum_pg_foreign_data_wrapper_fdwoptions,
                                &isnull);
        if (isnull)
            datum = PointerGetDatum(NULL);

        /* Transform the options */
        datum = transformGenericOptions(ForeignDataWrapperRelationId,
                                        datum,
                                        stmt->options,
                                        fdwvalidator);

        if (PointerIsValid(DatumGetPointer(datum)))
            repl_val[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = datum;
        else
            repl_null[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;

        repl_repl[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;
    }

    /* Everything looks good - update the tuple */
    tp = heap_modify_tuple(tp, RelationGetDescr(rel),
                           repl_val, repl_null, repl_repl);

    CatalogTupleUpdate(rel, &tp->t_self, tp);

    heap_freetuple(tp);

    ObjectAddressSet(myself, ForeignDataWrapperRelationId, fdwId);

    /* Update function dependencies if we changed them */
    if (handler_given || validator_given)
    {
        ObjectAddress referenced;

        /*
         * Flush all existing dependency records of this FDW on functions; we
         * assume there can be none other than the ones we are fixing.
         */
        deleteDependencyRecordsForClass(ForeignDataWrapperRelationId,
                                        fdwId,
                                        ProcedureRelationId,
                                        DEPENDENCY_NORMAL);

        /* And build new ones. */

        if (OidIsValid(fdwhandler))
        {
            referenced.classId = ProcedureRelationId;
            referenced.objectId = fdwhandler;
            referenced.objectSubId = 0;
            recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
        }

        if (OidIsValid(fdwvalidator))
        {
            referenced.classId = ProcedureRelationId;
            referenced.objectId = fdwvalidator;
            referenced.objectSubId = 0;
            recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
        }
    }

    InvokeObjectPostAlterHook(ForeignDataWrapperRelationId, fdwId, 0);

    heap_close(rel, RowExclusiveLock);

    return myself;
}

AlterForeignDataWrapperOwner()

ObjectAddress AlterForeignDataWrapperOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 277 of file foreigncmds.c.

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

Referenced by ExecAlterOwnerStmt().

{
    Oid         fdwId;
    HeapTuple   tup;
    Relation    rel;
    ObjectAddress address;

    rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);

    tup = SearchSysCacheCopy1(FOREIGNDATAWRAPPERNAME, CStringGetDatum(name));

    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("foreign-data wrapper \"%s\" does not exist", name)));

    fdwId = HeapTupleGetOid(tup);

    AlterForeignDataWrapperOwner_internal(rel, tup, newOwnerId);

    ObjectAddressSet(address, ForeignDataWrapperRelationId, fdwId);

    heap_freetuple(tup);

    heap_close(rel, RowExclusiveLock);

    return address;
}

AlterForeignDataWrapperOwner_oid()

void AlterForeignDataWrapperOwner_oid	(	Oid	fwdId,
		Oid	newOwnerId
	)

Definition at line 312 of file foreigncmds.c.

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

Referenced by shdepReassignOwned().

{
    HeapTuple   tup;
    Relation    rel;

    rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);

    tup = SearchSysCacheCopy1(FOREIGNDATAWRAPPEROID, ObjectIdGetDatum(fwdId));

    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("foreign-data wrapper with OID %u does not exist", fwdId)));

    AlterForeignDataWrapperOwner_internal(rel, tup, newOwnerId);

    heap_freetuple(tup);

    heap_close(rel, RowExclusiveLock);
}

AlterForeignServer()

ObjectAddress AlterForeignServer

(

AlterForeignServerStmt *

stmt

)

Definition at line 985 of file foreigncmds.c.

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

Referenced by ProcessUtilitySlow().

{
    Relation    rel;
    HeapTuple   tp;
    Datum       repl_val[Natts_pg_foreign_server];
    bool        repl_null[Natts_pg_foreign_server];
    bool        repl_repl[Natts_pg_foreign_server];
    Oid         srvId;
    Form_pg_foreign_server srvForm;
    ObjectAddress address;

    rel = heap_open(ForeignServerRelationId, RowExclusiveLock);

    tp = SearchSysCacheCopy1(FOREIGNSERVERNAME,
                             CStringGetDatum(stmt->servername));

    if (!HeapTupleIsValid(tp))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("server \"%s\" does not exist", stmt->servername)));

    srvId = HeapTupleGetOid(tp);
    srvForm = (Form_pg_foreign_server) GETSTRUCT(tp);

    /*
     * Only owner or a superuser can ALTER a SERVER.
     */
    if (!pg_foreign_server_ownercheck(srvId, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, 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);

    heap_close(rel, RowExclusiveLock);

    return address;
}

AlterForeignServerOwner()

ObjectAddress AlterForeignServerOwner	(	const char *	name,
		Oid	newOwnerId
	)

Definition at line 414 of file foreigncmds.c.

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

Referenced by ExecAlterOwnerStmt().

{
    Oid         servOid;
    HeapTuple   tup;
    Relation    rel;
    ObjectAddress address;

    rel = heap_open(ForeignServerRelationId, RowExclusiveLock);

    tup = SearchSysCacheCopy1(FOREIGNSERVERNAME, CStringGetDatum(name));

    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("server \"%s\" does not exist", name)));

    servOid = HeapTupleGetOid(tup);

    AlterForeignServerOwner_internal(rel, tup, newOwnerId);

    ObjectAddressSet(address, ForeignServerRelationId, servOid);

    heap_freetuple(tup);

    heap_close(rel, RowExclusiveLock);

    return address;
}

AlterForeignServerOwner_oid()

void AlterForeignServerOwner_oid	(	Oid	,
		Oid	newOwnerId
	)

Definition at line 447 of file foreigncmds.c.

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

Referenced by shdepReassignOwned().

{
    HeapTuple   tup;
    Relation    rel;

    rel = heap_open(ForeignServerRelationId, RowExclusiveLock);

    tup = SearchSysCacheCopy1(FOREIGNSERVEROID, ObjectIdGetDatum(srvId));

    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("foreign server with OID %u does not exist", srvId)));

    AlterForeignServerOwner_internal(rel, tup, newOwnerId);

    heap_freetuple(tup);

    heap_close(rel, RowExclusiveLock);
}

AlterFunction()

ObjectAddress AlterFunction	(	ParseState *	pstate,
		AlterFunctionStmt *	stmt
	)

Definition at line 1174 of file functioncmds.c.

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

Referenced by ProcessUtilitySlow().

{
    HeapTuple   tup;
    Oid         funcOid;
    Form_pg_proc procForm;
    bool        is_procedure;
    Relation    rel;
    ListCell   *l;
    DefElem    *volatility_item = NULL;
    DefElem    *strict_item = NULL;
    DefElem    *security_def_item = NULL;
    DefElem    *leakproof_item = NULL;
    List       *set_items = NIL;
    DefElem    *cost_item = NULL;
    DefElem    *rows_item = NULL;
    DefElem    *parallel_item = NULL;
    ObjectAddress address;

    rel = heap_open(ProcedureRelationId, RowExclusiveLock);

    funcOid = LookupFuncWithArgs(stmt->objtype, stmt->func, false);

    tup = SearchSysCacheCopy1(PROCOID, ObjectIdGetDatum(funcOid));
    if (!HeapTupleIsValid(tup)) /* should not happen */
        elog(ERROR, "cache lookup failed for function %u", funcOid);

    procForm = (Form_pg_proc) GETSTRUCT(tup);

    /* Permission check: must own function */
    if (!pg_proc_ownercheck(funcOid, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, 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,
                                     &parallel_item) == false)
            elog(ERROR, "option \"%s\" not recognized", defel->defname);
    }

    if (volatility_item)
        procForm->provolatile = interpret_func_volatility(volatility_item);
    if (strict_item)
        procForm->proisstrict = intVal(strict_item->arg);
    if (security_def_item)
        procForm->prosecdef = intVal(security_def_item->arg);
    if (leakproof_item)
    {
        procForm->proleakproof = intVal(leakproof_item->arg);
        if (procForm->proleakproof && !superuser())
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("only superuser can define a leakproof function")));
    }
    if (cost_item)
    {
        procForm->procost = defGetNumeric(cost_item);
        if (procForm->procost <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("COST must be positive")));
    }
    if (rows_item)
    {
        procForm->prorows = defGetNumeric(rows_item);
        if (procForm->prorows <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("ROWS must be positive")));
        if (!procForm->proretset)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("ROWS is not applicable when function does not return a set")));
    }
    if (set_items)
    {
        Datum       datum;
        bool        isnull;
        ArrayType  *a;
        Datum       repl_val[Natts_pg_proc];
        bool        repl_null[Natts_pg_proc];
        bool        repl_repl[Natts_pg_proc];

        /* extract existing proconfig setting */
        datum = SysCacheGetAttr(PROCOID, tup, Anum_pg_proc_proconfig, &isnull);
        a = isnull ? NULL : DatumGetArrayTypeP(datum);

        /* update according to each SET or RESET item, left to right */
        a = update_proconfig_value(a, set_items);

        /* update the tuple */
        memset(repl_repl, false, sizeof(repl_repl));
        repl_repl[Anum_pg_proc_proconfig - 1] = true;

        if (a == NULL)
        {
            repl_val[Anum_pg_proc_proconfig - 1] = (Datum) 0;
            repl_null[Anum_pg_proc_proconfig - 1] = true;
        }
        else
        {
            repl_val[Anum_pg_proc_proconfig - 1] = PointerGetDatum(a);
            repl_null[Anum_pg_proc_proconfig - 1] = false;
        }

        tup = heap_modify_tuple(tup, RelationGetDescr(rel),
                                repl_val, repl_null, repl_repl);
    }
    if (parallel_item)
        procForm->proparallel = interpret_func_parallel(parallel_item);

    /* Do the update */
    CatalogTupleUpdate(rel, &tup->t_self, tup);

    InvokeObjectPostAlterHook(ProcedureRelationId, funcOid, 0);

    ObjectAddressSet(address, ProcedureRelationId, funcOid);

    heap_close(rel, NoLock);
    heap_freetuple(tup);

    return address;
}

AlterOperator()

ObjectAddress AlterOperator

(

AlterOperatorStmt *

stmt

)

Definition at line 384 of file operatorcmds.c.

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

Referenced by ProcessUtilitySlow().

{
    ObjectAddress address;
    Oid         oprId;
    Relation    catalog;
    HeapTuple   tup;
    Form_pg_operator oprForm;
    int         i;
    ListCell   *pl;
    Datum       values[Natts_pg_operator];
    bool        nulls[Natts_pg_operator];
    bool        replaces[Natts_pg_operator];
    List       *restrictionName = NIL;  /* optional restrict. sel. procedure */
    bool        updateRestriction = false;
    Oid         restrictionOid;
    List       *joinName = NIL; /* optional join sel. procedure */
    bool        updateJoin = false;
    Oid         joinOid;

    /* Look up the operator */
    oprId = LookupOperWithArgs(stmt->opername, false);
    catalog = heap_open(OperatorRelationId, RowExclusiveLock);
    tup = SearchSysCacheCopy1(OPEROID, ObjectIdGetDatum(oprId));
    if (tup == NULL)
        elog(ERROR, "cache lookup failed for operator %u", oprId);
    oprForm = (Form_pg_operator) GETSTRUCT(tup);

    /* Process options */
    foreach(pl, stmt->options)
    {
        DefElem    *defel = (DefElem *) lfirst(pl);
        List       *param;

        if (defel->arg == NULL)
            param = NIL;        /* NONE, removes the function */
        else
            param = defGetQualifiedName(defel);

        if (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, "procedure") == 0 ||
                 strcmp(defel->defname, "commutator") == 0 ||
                 strcmp(defel->defname, "negator") == 0 ||
                 strcmp(defel->defname, "hashes") == 0 ||
                 strcmp(defel->defname, "merges") == 0)
        {
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("operator attribute \"%s\" cannot be changed",
                            defel->defname)));
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("operator attribute \"%s\" not recognized",
                            defel->defname)));
    }

    /* Check permissions. Must be owner. */
    if (!pg_oper_ownercheck(oprId, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_OPERATOR,
                       NameStr(oprForm->oprname));

    /*
     * Look up restriction and join estimators if specified
     */
    if (restrictionName)
        restrictionOid = ValidateRestrictionEstimator(restrictionName);
    else
        restrictionOid = InvalidOid;
    if (joinName)
        joinOid = ValidateJoinEstimator(joinName);
    else
        joinOid = InvalidOid;

    /* Perform additional checks, like OperatorCreate does */
    if (!(OidIsValid(oprForm->oprleft) && OidIsValid(oprForm->oprright)))
    {
        /* If it's not a binary op, these things mustn't be set: */
        if (OidIsValid(joinOid))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only binary operators can have join selectivity")));
    }

    if (oprForm->oprresult != BOOLOID)
    {
        if (OidIsValid(restrictionOid))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only boolean operators can have restriction selectivity")));
        if (OidIsValid(joinOid))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("only boolean operators can have join selectivity")));
    }

    /* Update the tuple */
    for (i = 0; i < Natts_pg_operator; ++i)
    {
        values[i] = (Datum) 0;
        replaces[i] = false;
        nulls[i] = false;
    }
    if (updateRestriction)
    {
        replaces[Anum_pg_operator_oprrest - 1] = true;
        values[Anum_pg_operator_oprrest - 1] = restrictionOid;
    }
    if (updateJoin)
    {
        replaces[Anum_pg_operator_oprjoin - 1] = true;
        values[Anum_pg_operator_oprjoin - 1] = joinOid;
    }

    tup = heap_modify_tuple(tup, RelationGetDescr(catalog),
                            values, nulls, replaces);

    CatalogTupleUpdate(catalog, &tup->t_self, tup);

    address = makeOperatorDependencies(tup, true);

    InvokeObjectPostAlterHook(OperatorRelationId, oprId, 0);

    heap_close(catalog, NoLock);

    return address;
}

AlterOpFamily()

Oid AlterOpFamily

(

AlterOpFamilyStmt *

stmt

)

Definition at line 764 of file opclasscmds.c.

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

Referenced by ProcessUtilitySlow().

{
    Oid         amoid,          /* our AM's oid */
                opfamilyoid;    /* oid of opfamily */
    int         maxOpNumber,    /* amstrategies value */
                maxProcNumber;  /* amsupport value */
    HeapTuple   tup;
    IndexAmRoutine *amroutine;

    /* Get necessary info about access method */
    tup = SearchSysCache1(AMNAME, CStringGetDatum(stmt->amname));
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("access method \"%s\" does not exist",
                        stmt->amname)));

    amoid = HeapTupleGetOid(tup);
    amroutine = GetIndexAmRoutineByAmId(amoid, false);
    ReleaseSysCache(tup);

    maxOpNumber = amroutine->amstrategies;
    /* if amstrategies is zero, just enforce that op numbers fit in int16 */
    if (maxOpNumber <= 0)
        maxOpNumber = SHRT_MAX;
    maxProcNumber = amroutine->amsupport;

    /* XXX Should we make any privilege check against the AM? */

    /* Look up the opfamily */
    opfamilyoid = get_opfamily_oid(amoid, stmt->opfamilyname, false);

    /*
     * Currently, we require superuser privileges to alter an opfamily.
     *
     * XXX re-enable NOT_USED code sections below if you remove this test.
     */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be superuser to alter an operator family")));

    /*
     * ADD and DROP cases need separate code from here on down.
     */
    if (stmt->isDrop)
        AlterOpFamilyDrop(stmt, amoid, opfamilyoid,
                          maxOpNumber, maxProcNumber, stmt->items);
    else
        AlterOpFamilyAdd(stmt, amoid, opfamilyoid,
                         maxOpNumber, maxProcNumber, stmt->items);

    return opfamilyoid;
}

AlterTSConfiguration()

ObjectAddress AlterTSConfiguration

(

AlterTSConfigurationStmt *

stmt

)

Definition at line 1173 of file tsearchcmds.c.

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

Referenced by ProcessUtilitySlow().

{
    HeapTuple   tup;
    Oid         cfgId;
    Relation    relMap;
    ObjectAddress address;

    /* Find the configuration */
    tup = GetTSConfigTuple(stmt->cfgname);
    if (!HeapTupleIsValid(tup))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("text search configuration \"%s\" does not exist",
                        NameListToString(stmt->cfgname))));

    cfgId = HeapTupleGetOid(tup);

    /* must be owner */
    if (!pg_ts_config_ownercheck(HeapTupleGetOid(tup), GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_TSCONFIGURATION,
                       NameListToString(stmt->cfgname));

    relMap = heap_open(TSConfigMapRelationId, RowExclusiveLock);

    /* Add or drop mappings */
    if (stmt->dicts)
        MakeConfigurationMapping(stmt, tup, relMap);
    else if (stmt->tokentype)
        DropConfigurationMapping(stmt, tup, relMap);

    /* Update dependencies */
    makeConfigurationDependencies(tup, true, relMap);

    InvokeObjectPostAlterHook(TSConfigRelationId,
                              HeapTupleGetOid(tup), 0);

    ObjectAddressSet(address, TSConfigRelationId, cfgId);

    heap_close(relMap, RowExclusiveLock);

    ReleaseSysCache(tup);

    return address;
}

AlterTSDictionary()

ObjectAddress AlterTSDictionary

(

AlterTSDictionaryStmt *

stmt

)

Definition at line 525 of file tsearchcmds.c.

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

Referenced by ProcessUtilitySlow().

{
    HeapTuple   tup,
                newtup;
    Relation    rel;
    Oid         dictId;
    ListCell   *pl;
    List       *dictoptions;
    Datum       opt;
    bool        isnull;
    Datum       repl_val[Natts_pg_ts_dict];
    bool        repl_null[Natts_pg_ts_dict];
    bool        repl_repl[Natts_pg_ts_dict];
    ObjectAddress address;

    dictId = get_ts_dict_oid(stmt->dictname, false);

    rel = heap_open(TSDictionaryRelationId, RowExclusiveLock);

    tup = SearchSysCache1(TSDICTOID, ObjectIdGetDatum(dictId));

    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for text search dictionary %u",
             dictId);

    /* must be owner */
    if (!pg_ts_dict_ownercheck(dictId, GetUserId()))
        aclcheck_error(ACLCHECK_NOT_OWNER, 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;
        ListCell   *prev;
        ListCell   *next;

        /*
         * Remove any matches ...
         */
        prev = NULL;
        for (cell = list_head(dictoptions); cell; cell = next)
        {
            DefElem    *oldel = (DefElem *) lfirst(cell);

            next = lnext(cell);
            if (strcmp(oldel->defname, defel->defname) == 0)
                dictoptions = list_delete_cell(dictoptions, cell, prev);
            else
                prev = cell;
        }

        /*
         * and add new value if it's got one
         */
        if (defel->arg)
            dictoptions = lappend(dictoptions, defel);
    }

    /*
     * Validate
     */
    verify_dictoptions(((Form_pg_ts_dict) GETSTRUCT(tup))->dicttemplate,
                       dictoptions);

    /*
     * Looks good, update
     */
    memset(repl_val, 0, sizeof(repl_val));
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));

    if (dictoptions)
        repl_val[Anum_pg_ts_dict_dictinitoption - 1] =
            PointerGetDatum(serialize_deflist(dictoptions));
    else
        repl_null[Anum_pg_ts_dict_dictinitoption - 1] = true;
    repl_repl[Anum_pg_ts_dict_dictinitoption - 1] = true;

    newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
                               repl_val, repl_null, repl_repl);

    CatalogTupleUpdate(rel, &newtup->t_self, newtup);

    InvokeObjectPostAlterHook(TSDictionaryRelationId, dictId, 0);

    ObjectAddressSet(address, TSDictionaryRelationId, dictId);

    /*
     * NOTE: because we only support altering the options, not the template,
     * there is no need to update dependencies.  This might have to change if
     * the options ever reference inside-the-database objects.
     */

    heap_freetuple(newtup);
    ReleaseSysCache(tup);

    heap_close(rel, RowExclusiveLock);

    return address;
}

AlterUserMapping()

ObjectAddress AlterUserMapping

(

AlterUserMappingStmt *

stmt

)

Definition at line 1250 of file foreigncmds.c.

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

Referenced by ProcessUtilitySlow().

{
    Relation    rel;
    HeapTuple   tp;
    Datum       repl_val[Natts_pg_user_mapping];
    bool        repl_null[Natts_pg_user_mapping];
    bool        repl_repl[Natts_pg_user_mapping];
    Oid         useId;
    Oid         umId;
    ForeignServer *srv;
    ObjectAddress address;
    RoleSpec   *role = (RoleSpec *) stmt->user;

    rel = heap_open(UserMappingRelationId, RowExclusiveLock);

    if (role->roletype == ROLESPEC_PUBLIC)
        useId = ACL_ID_PUBLIC;
    else
        useId = get_rolespec_oid(stmt->user, false);

    srv = GetForeignServerByName(stmt->servername, false);

    umId = GetSysCacheOid2(USERMAPPINGUSERSERVER,
                           ObjectIdGetDatum(useId),
                           ObjectIdGetDatum(srv->serverid));
    if (!OidIsValid(umId))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("user mapping for \"%s\" does not exist for the server",
                        MappingUserName(useId))));

    user_mapping_ddl_aclcheck(useId, srv->serverid, stmt->servername);

    tp = SearchSysCacheCopy1(USERMAPPINGOID, ObjectIdGetDatum(umId));

    if (!HeapTupleIsValid(tp))
        elog(ERROR, "cache lookup failed for user mapping %u", umId);

    memset(repl_val, 0, sizeof(repl_val));
    memset(repl_null, false, sizeof(repl_null));
    memset(repl_repl, false, sizeof(repl_repl));

    if (stmt->options)
    {
        ForeignDataWrapper *fdw;
        Datum       datum;
        bool        isnull;

        /*
         * Process the options.
         */

        fdw = GetForeignDataWrapper(srv->fdwid);

        datum = SysCacheGetAttr(USERMAPPINGUSERSERVER,
                                tp,
                                Anum_pg_user_mapping_umoptions,
                                &isnull);
        if (isnull)
            datum = PointerGetDatum(NULL);

        /* Prepare the options array */
        datum = transformGenericOptions(UserMappingRelationId,
                                        datum,
                                        stmt->options,
                                        fdw->fdwvalidator);

        if (PointerIsValid(DatumGetPointer(datum)))
            repl_val[Anum_pg_user_mapping_umoptions - 1] = datum;
        else
            repl_null[Anum_pg_user_mapping_umoptions - 1] = true;

        repl_repl[Anum_pg_user_mapping_umoptions - 1] = true;
    }

    /* Everything looks good - update the tuple */
    tp = heap_modify_tuple(tp, RelationGetDescr(rel),
                           repl_val, repl_null, repl_repl);

    CatalogTupleUpdate(rel, &tp->t_self, tp);

    ObjectAddressSet(address, UserMappingRelationId, umId);

    heap_freetuple(tp);

    heap_close(rel, RowExclusiveLock);

    return address;
}

CheckIndexCompatible()

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

Definition at line 126 of file indexcmds.c.

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

Referenced by TryReuseIndex().

{
    bool        isconstraint;
    Oid        *typeObjectId;
    Oid        *collationObjectId;
    Oid        *classObjectId;
    Oid         accessMethodId;
    Oid         relationId;
    HeapTuple   tuple;
    Form_pg_index indexForm;
    Form_pg_am  accessMethodForm;
    IndexAmRoutine *amRoutine;
    bool        amcanorder;
    int16      *coloptions;
    IndexInfo  *indexInfo;
    int         numberOfAttributes;
    int         old_natts;
    bool        isnull;
    bool        ret = true;
    oidvector  *old_indclass;
    oidvector  *old_indcollation;
    Relation    irel;
    int         i;
    Datum       d;

    /* Caller should already have the relation locked in some way. */
    relationId = IndexGetRelation(oldId, false);

    /*
     * We can pretend isconstraint = false unconditionally.  It only serves to
     * decide the text of an error message that should never happen for us.
     */
    isconstraint = false;

    numberOfAttributes = list_length(attributeList);
    Assert(numberOfAttributes > 0);
    Assert(numberOfAttributes <= INDEX_MAX_KEYS);

    /* look up the access method */
    tuple = SearchSysCache1(AMNAME, PointerGetDatum(accessMethodName));
    if (!HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("access method \"%s\" does not exist",
                        accessMethodName)));
    accessMethodId = HeapTupleGetOid(tuple);
    accessMethodForm = (Form_pg_am) GETSTRUCT(tuple);
    amRoutine = GetIndexAmRoutine(accessMethodForm->amhandler);
    ReleaseSysCache(tuple);

    amcanorder = amRoutine->amcanorder;

    /*
     * Compute the operator classes, collations, and exclusion operators for
     * the new index, so we can test whether it's compatible with the existing
     * one.  Note that ComputeIndexAttrs might fail here, but that's OK:
     * DefineIndex would have called this function with the same arguments
     * later on, and it would have failed then anyway.  Our attributeList
     * contains only key attributes, thus we're filling ii_NumIndexAttrs and
     * ii_NumIndexKeyAttrs with same value.
     */
    indexInfo = makeNode(IndexInfo);
    indexInfo->ii_NumIndexAttrs = numberOfAttributes;
    indexInfo->ii_NumIndexKeyAttrs = numberOfAttributes;
    indexInfo->ii_Expressions = NIL;
    indexInfo->ii_ExpressionsState = NIL;
    indexInfo->ii_PredicateState = NULL;
    indexInfo->ii_ExclusionOps = NULL;
    indexInfo->ii_ExclusionProcs = NULL;
    indexInfo->ii_ExclusionStrats = NULL;
    indexInfo->ii_Am = accessMethodId;
    indexInfo->ii_AmCache = NULL;
    indexInfo->ii_Context = CurrentMemoryContext;
    typeObjectId = (Oid *) palloc(numberOfAttributes * sizeof(Oid));
    collationObjectId = (Oid *) palloc(numberOfAttributes * sizeof(Oid));
    classObjectId = (Oid *) palloc(numberOfAttributes * sizeof(Oid));
    coloptions = (int16 *) palloc(numberOfAttributes * sizeof(int16));
    ComputeIndexAttrs(indexInfo,
                      typeObjectId, collationObjectId, classObjectId,
                      coloptions, attributeList,
                      exclusionOpNames, relationId,
                      accessMethodName, accessMethodId,
                      amcanorder, isconstraint);


    /* Get the soon-obsolete pg_index tuple. */
    tuple = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(oldId));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for index %u", oldId);
    indexForm = (Form_pg_index) GETSTRUCT(tuple);

    /*
     * We don't assess expressions or predicates; assume incompatibility.
     * Also, if the index is invalid for any reason, treat it as incompatible.
     */
    if (!(heap_attisnull(tuple, Anum_pg_index_indpred, NULL) &&
          heap_attisnull(tuple, Anum_pg_index_indexprs, NULL) &&
          IndexIsValid(indexForm)))
    {
        ReleaseSysCache(tuple);
        return false;
    }

    /* Any change in operator class or collation breaks compatibility. */
    old_natts = indexForm->indnkeyatts;
    Assert(old_natts == numberOfAttributes);

    d = SysCacheGetAttr(INDEXRELID, tuple, Anum_pg_index_indcollation, &isnull);
    Assert(!isnull);
    old_indcollation = (oidvector *) DatumGetPointer(d);

    d = SysCacheGetAttr(INDEXRELID, tuple, Anum_pg_index_indclass, &isnull);
    Assert(!isnull);
    old_indclass = (oidvector *) DatumGetPointer(d);

    ret = (memcmp(old_indclass->values, classObjectId,
                  old_natts * sizeof(Oid)) == 0 &&
           memcmp(old_indcollation->values, collationObjectId,
                  old_natts * sizeof(Oid)) == 0);

    ReleaseSysCache(tuple);

    if (!ret)
        return false;

    /* For polymorphic opcintype, column type changes break compatibility. */
    irel = index_open(oldId, AccessShareLock);  /* caller probably has a lock */
    for (i = 0; i < old_natts; i++)
    {
        if (IsPolymorphicType(get_opclass_input_type(classObjectId[i])) &&
            TupleDescAttr(irel->rd_att, i)->atttypid != typeObjectId[i])
        {
            ret = false;
            break;
        }
    }

    /* Any change in exclusion operator selections breaks compatibility. */
    if (ret && indexInfo->ii_ExclusionOps != NULL)
    {
        Oid        *old_operators,
                   *old_procs;
        uint16     *old_strats;

        RelationGetExclusionInfo(irel, &old_operators, &old_procs, &old_strats);
        ret = memcmp(old_operators, indexInfo->ii_ExclusionOps,
                     old_natts * sizeof(Oid)) == 0;

        /* Require an exact input type match for polymorphic operators. */
        if (ret)
        {
            for (i = 0; i < old_natts && ret; i++)
            {
                Oid         left,
                            right;

                op_input_types(indexInfo->ii_ExclusionOps[i], &left, &right);
                if ((IsPolymorphicType(left) || IsPolymorphicType(right)) &&
                    TupleDescAttr(irel->rd_att, i)->atttypid != typeObjectId[i])
                {
                    ret = false;
                    break;
                }
            }
        }
    }

    index_close(irel, NoLock);
    return ret;
}

ChooseRelationName()

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

Definition at line 1988 of file indexcmds.c.

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

Referenced by ChooseIndexName(), and generateSerialExtraStmts().

{
    int         pass = 0;
    char       *relname = NULL;
    char        modlabel[NAMEDATALEN];

    /* try the unmodified label first */
    StrNCpy(modlabel, label, sizeof(modlabel));

    for (;;)
    {
        relname = makeObjectName(name1, name2, modlabel);

        if (!OidIsValid(get_relname_relid(relname, namespaceid)))
            break;

        /* found a conflict, so try a new name component */
        pfree(relname);
        snprintf(modlabel, sizeof(modlabel), "%s%d", label, ++pass);
    }

    return relname;
}

CreateAccessMethod()

ObjectAddress CreateAccessMethod

(

CreateAmStmt *

stmt

)

Definition at line 41 of file amcmds.c.

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

Referenced by ProcessUtilitySlow().

{
    Relation    rel;
    ObjectAddress myself;
    ObjectAddress referenced;
    Oid         amoid;
    Oid         amhandler;
    bool        nulls[Natts_pg_am];
    Datum       values[Natts_pg_am];
    HeapTuple   tup;

    rel = heap_open(AccessMethodRelationId, RowExclusiveLock);

    /* Must be super user */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to create access method \"%s\"",
                        stmt->amname),
                 errhint("Must be superuser to create an access method.")));

    /* Check if name is used */
    amoid = GetSysCacheOid1(AMNAME, CStringGetDatum(stmt->amname));
    if (OidIsValid(amoid))
    {
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("access method \"%s\" already exists",
                        stmt->amname)));
    }

    /*
     * Get the handler function oid, verifying the AM type while at it.
     */
    amhandler = lookup_index_am_handler_func(stmt->handler_name, stmt->amtype);

    /*
     * Insert tuple into pg_am.
     */
    memset(values, 0, sizeof(values));
    memset(nulls, false, sizeof(nulls));

    values[Anum_pg_am_amname - 1] =
        DirectFunctionCall1(namein, CStringGetDatum(stmt->amname));
    values[Anum_pg_am_amhandler - 1] = ObjectIdGetDatum(amhandler);
    values[Anum_pg_am_amtype - 1] = CharGetDatum(stmt->amtype);

    tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);

    amoid = CatalogTupleInsert(rel, tup);
    heap_freetuple(tup);

    myself.classId = AccessMethodRelationId;
    myself.objectId = amoid;
    myself.objectSubId = 0;

    /* Record dependency on handler function */
    referenced.classId = ProcedureRelationId;
    referenced.objectId = amhandler;
    referenced.objectSubId = 0;

    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

    recordDependencyOnCurrentExtension(&myself, false);

    heap_close(rel, RowExclusiveLock);

    return myself;
}

CreateCast()

ObjectAddress CreateCast

(

CreateCastStmt *

stmt

)

Definition at line 1410 of file functioncmds.c.

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, CASTSOURCETARGET, CatalogTupleInsert(), CharGetDatum, ObjectAddress::classId, COERCION_ASSIGNMENT, COERCION_EXPLICIT, COERCION_IMPLICIT, CreateCastStmt::context, DEPENDENCY_NORMAL, elog, ereport, errcode(), ERRCODE_DUPLICATE_OBJECT, errmsg(), ERROR, format_type_be(), CreateCastStmt::func, get_element_type(), get_typlenbyvalalign(), get_typtype(), GETSTRUCT, GetUserId(), heap_close, heap_form_tuple(), heap_freetuple(), heap_open(), HeapTupleIsValid, CreateCastStmt::inout, InvalidOid, InvokeObjectPostCreateHook, IsBinaryCoercible(), LookupFuncWithArgs(), MemSet, OBJECT_FUNCTION, ObjectAddress::objectId, ObjectIdGetDatum, ObjectAddress::objectSubId, OidIsValid, pg_type_aclcheck(), pg_type_ownercheck(), PROCOID, recordDependencyOn(), recordDependencyOnCurrentExtension(), RelationGetDescr, ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), SearchSysCache2(), CreateCastStmt::sourcetype, superuser(), CreateCastStmt::targettype, TypeNameToString(), typenameTypeId(), values, and WARNING.

Referenced by ProcessUtilitySlow().

{
    Oid         sourcetypeid;
    Oid         targettypeid;
    char        sourcetyptype;
    char        targettyptype;
    Oid         funcid;
    Oid         castid;
    int         nargs;
    char        castcontext;
    char        castmethod;
    Relation    relation;
    HeapTuple   tuple;
    Datum       values[Natts_pg_cast];
    bool        nulls[Natts_pg_cast];
    ObjectAddress myself,
                referenced;
    AclResult   aclresult;

    sourcetypeid = typenameTypeId(NULL, stmt->sourcetype);
    targettypeid = typenameTypeId(NULL, stmt->targettype);
    sourcetyptype = get_typtype(sourcetypeid);
    targettyptype = get_typtype(targettypeid);

    /* No pseudo-types allowed */
    if (sourcetyptype == TYPTYPE_PSEUDO)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("source data type %s is a pseudo-type",
                        TypeNameToString(stmt->sourcetype))));

    if (targettyptype == TYPTYPE_PSEUDO)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("target data type %s is a pseudo-type",
                        TypeNameToString(stmt->targettype))));

    /* Permission check */
    if (!pg_type_ownercheck(sourcetypeid, GetUserId())
        && !pg_type_ownercheck(targettypeid, GetUserId()))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be owner of type %s or type %s",
                        format_type_be(sourcetypeid),
                        format_type_be(targettypeid))));

    aclresult = pg_type_aclcheck(sourcetypeid, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, sourcetypeid);

    aclresult = pg_type_aclcheck(targettypeid, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, targettypeid);

    /* Domains are allowed for historical reasons, but we warn */
    if (sourcetyptype == TYPTYPE_DOMAIN)
        ereport(WARNING,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cast will be ignored because the source data type is a domain")));

    else if (targettyptype == TYPTYPE_DOMAIN)
        ereport(WARNING,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("cast will be ignored because the target data type is a domain")));

    /* Determine the cast method */
    if (stmt->func != NULL)
        castmethod = COERCION_METHOD_FUNCTION;
    else if (stmt->inout)
        castmethod = COERCION_METHOD_INOUT;
    else
        castmethod = COERCION_METHOD_BINARY;

    if (castmethod == COERCION_METHOD_FUNCTION)
    {
        Form_pg_proc procstruct;

        funcid = LookupFuncWithArgs(OBJECT_FUNCTION, stmt->func, false);

        tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for function %u", funcid);

        procstruct = (Form_pg_proc) GETSTRUCT(tuple);
        nargs = procstruct->pronargs;
        if (nargs < 1 || nargs > 3)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("cast function must take one to three arguments")));
        if (!IsBinaryCoercible(sourcetypeid, procstruct->proargtypes.values[0]))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("argument of cast function must match or be binary-coercible from source data type")));
        if (nargs > 1 && procstruct->proargtypes.values[1] != INT4OID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("second argument of cast function must be type %s",
                            "integer")));
        if (nargs > 2 && procstruct->proargtypes.values[2] != BOOLOID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("third argument of cast function must be type %s",
                            "boolean")));
        if (!IsBinaryCoercible(procstruct->prorettype, targettypeid))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("return data type of cast function must match or be binary-coercible to target data type")));

        /*
         * Restricting the volatility of a cast function may or may not be a
         * good idea in the abstract, but it definitely breaks many old
         * user-defined types.  Disable this check --- tgl 2/1/03
         */
#ifdef NOT_USED
        if (procstruct->provolatile == PROVOLATILE_VOLATILE)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("cast function must not be volatile")));
#endif
        if (procstruct->prokind != PROKIND_FUNCTION)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("cast function must be a normal function")));
        if (procstruct->proretset)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("cast function must not return a set")));

        ReleaseSysCache(tuple);
    }
    else
    {
        funcid = InvalidOid;
        nargs = 0;
    }

    if (castmethod == COERCION_METHOD_BINARY)
    {
        int16       typ1len;
        int16       typ2len;
        bool        typ1byval;
        bool        typ2byval;
        char        typ1align;
        char        typ2align;

        /*
         * Must be superuser to create binary-compatible casts, since
         * erroneous casts can easily crash the backend.
         */
        if (!superuser())
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                     errmsg("must be superuser to create a cast WITHOUT FUNCTION")));

        /*
         * Also, insist that the types match as to size, alignment, and
         * pass-by-value attributes; this provides at least a crude check that
         * they have similar representations.  A pair of types that fail this
         * test should certainly not be equated.
         */
        get_typlenbyvalalign(sourcetypeid, &typ1len, &typ1byval, &typ1align);
        get_typlenbyvalalign(targettypeid, &typ2len, &typ2byval, &typ2align);
        if (typ1len != typ2len ||
            typ1byval != typ2byval ||
            typ1align != typ2align)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("source and target data types are not physically compatible")));

        /*
         * We know that composite, enum and array types are never binary-
         * compatible with each other.  They all have OIDs embedded in them.
         *
         * Theoretically you could build a user-defined base type that is
         * binary-compatible with a composite, enum, or array type.  But we
         * disallow that too, as in practice such a cast is surely a mistake.
         * You can always work around that by writing a cast function.
         */
        if (sourcetyptype == TYPTYPE_COMPOSITE ||
            targettyptype == TYPTYPE_COMPOSITE)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("composite data types are not binary-compatible")));

        if (sourcetyptype == TYPTYPE_ENUM ||
            targettyptype == TYPTYPE_ENUM)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("enum data types are not binary-compatible")));

        if (OidIsValid(get_element_type(sourcetypeid)) ||
            OidIsValid(get_element_type(targettypeid)))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("array data types are not binary-compatible")));

        /*
         * We also disallow creating binary-compatibility casts involving
         * domains.  Casting from a domain to its base type is already
         * allowed, and casting the other way ought to go through domain
         * coercion to permit constraint checking.  Again, if you're intent on
         * having your own semantics for that, create a no-op cast function.
         *
         * NOTE: if we were to relax this, the above checks for composites
         * etc. would have to be modified to look through domains to their
         * base types.
         */
        if (sourcetyptype == TYPTYPE_DOMAIN ||
            targettyptype == TYPTYPE_DOMAIN)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("domain data types must not be marked binary-compatible")));
    }

    /*
     * Allow source and target types to be same only for length coercion
     * functions.  We assume a multi-arg function does length coercion.
     */
    if (sourcetypeid == targettypeid && nargs < 2)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("source data type and target data type are the same")));

    /* convert CoercionContext enum to char value for castcontext */
    switch (stmt->context)
    {
        case COERCION_IMPLICIT:
            castcontext = COERCION_CODE_IMPLICIT;
            break;
        case COERCION_ASSIGNMENT:
            castcontext = COERCION_CODE_ASSIGNMENT;
            break;
        case COERCION_EXPLICIT:
            castcontext = COERCION_CODE_EXPLICIT;
            break;
        default:
            elog(ERROR, "unrecognized CoercionContext: %d", stmt->context);
            castcontext = 0;    /* keep compiler quiet */
            break;
    }

    relation = heap_open(CastRelationId, RowExclusiveLock);

    /*
     * Check for duplicate.  This is just to give a friendly error message,
     * the unique index would catch it anyway (so no need to sweat about race
     * conditions).
     */
    tuple = SearchSysCache2(CASTSOURCETARGET,
                            ObjectIdGetDatum(sourcetypeid),
                            ObjectIdGetDatum(targettypeid));
    if (HeapTupleIsValid(tuple))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("cast from type %s to type %s already exists",
                        format_type_be(sourcetypeid),
                        format_type_be(targettypeid))));

    /* ready to go */
    values[Anum_pg_cast_castsource - 1] = ObjectIdGetDatum(sourcetypeid);
    values[Anum_pg_cast_casttarget - 1] = ObjectIdGetDatum(targettypeid);
    values[Anum_pg_cast_castfunc - 1] = ObjectIdGetDatum(funcid);
    values[Anum_pg_cast_castcontext - 1] = CharGetDatum(castcontext);
    values[Anum_pg_cast_castmethod - 1] = CharGetDatum(castmethod);

    MemSet(nulls, false, sizeof(nulls));

    tuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);

    castid = CatalogTupleInsert(relation, tuple);

    /* make dependency entries */
    myself.classId = CastRelationId;
    myself.objectId = castid;
    myself.objectSubId = 0;

    /* dependency on source type */
    referenced.classId = TypeRelationId;
    referenced.objectId = sourcetypeid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

    /* dependency on target type */
    referenced.classId = TypeRelationId;
    referenced.objectId = targettypeid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

    /* dependency on function */
    if (OidIsValid(funcid))
    {
        referenced.classId = ProcedureRelationId;
        referenced.objectId = funcid;
        referenced.objectSubId = 0;
        recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
    }

    /* dependency on extension */
    recordDependencyOnCurrentExtension(&myself, false);

    /* Post creation hook for new cast */
    InvokeObjectPostCreateHook(CastRelationId, castid, 0);

    heap_freetuple(tuple);

    heap_close(relation, RowExclusiveLock);

    return myself;
}

CreateForeignDataWrapper()

ObjectAddress CreateForeignDataWrapper

(

CreateFdwStmt *

stmt

)

Definition at line 560 of file foreigncmds.c.

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

Referenced by ProcessUtilitySlow().

{
    Relation    rel;
    Datum       values[Natts_pg_foreign_data_wrapper];
    bool        nulls[Natts_pg_foreign_data_wrapper];
    HeapTuple   tuple;
    Oid         fdwId;
    bool        handler_given;
    bool        validator_given;
    Oid         fdwhandler;
    Oid         fdwvalidator;
    Datum       fdwoptions;
    Oid         ownerId;
    ObjectAddress myself;
    ObjectAddress referenced;

    rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);

    /* Must be super user */
    if (!superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to create foreign-data wrapper \"%s\"",
                        stmt->fdwname),
                 errhint("Must be superuser to create a foreign-data wrapper.")));

    /* For now the owner cannot be specified on create. Use effective user ID. */
    ownerId = GetUserId();

    /*
     * Check that there is no other foreign-data wrapper by this name.
     */
    if (GetForeignDataWrapperByName(stmt->fdwname, true) != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("foreign-data wrapper \"%s\" already exists",
                        stmt->fdwname)));

    /*
     * Insert tuple into pg_foreign_data_wrapper.
     */
    memset(values, 0, sizeof(values));
    memset(nulls, false, sizeof(nulls));

    values[Anum_pg_foreign_data_wrapper_fdwname - 1] =
        DirectFunctionCall1(namein, CStringGetDatum(stmt->fdwname));
    values[Anum_pg_foreign_data_wrapper_fdwowner - 1] = ObjectIdGetDatum(ownerId);

    /* Lookup handler and validator functions, if given */
    parse_func_options(stmt->func_options,
                       &handler_given, &fdwhandler,
                       &validator_given, &fdwvalidator);

    values[Anum_pg_foreign_data_wrapper_fdwhandler - 1] = ObjectIdGetDatum(fdwhandler);
    values[Anum_pg_foreign_data_wrapper_fdwvalidator - 1] = ObjectIdGetDatum(fdwvalidator);

    nulls[Anum_pg_foreign_data_wrapper_fdwacl - 1] = true;

    fdwoptions = transformGenericOptions(ForeignDataWrapperRelationId,
                                         PointerGetDatum(NULL),
                                         stmt->options,
                                         fdwvalidator);

    if (PointerIsValid(DatumGetPointer(fdwoptions)))
        values[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = fdwoptions;
    else
        nulls[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;

    tuple = heap_form_tuple(rel->rd_att, values, nulls);

    fdwId = CatalogTupleInsert(rel, tuple);

    heap_freetuple(tuple);

    /* record dependencies */
    myself.classId = ForeignDataWrapperRelationId;
    myself.objectId = fdwId;
    myself.objectSubId = 0;

    if (OidIsValid(fdwhandler))
    {
        referenced.classId = ProcedureRelationId;
        referenced.objectId = fdwhandler;
        referenced.objectSubId = 0;
        recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
    }

    if (OidIsValid(fdwvalidator))
    {
        referenced.classId = ProcedureRelationId;
        referenced.objectId = fdwvalidator;
        referenced.objectSubId = 0;
        recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
    }

    recordDependencyOnOwner(ForeignDataWrapperRelationId, fdwId, ownerId);

    /* dependency on extension */
    recordDependencyOnCurrentExtension(&myself, false);

    /* Post creation hook for new foreign data wrapper */
    InvokeObjectPostCreateHook(ForeignDataWrapperRelationId, fdwId, 0);

    heap_close(rel, RowExclusiveLock);

    return myself;
}

CreateForeignServer()

ObjectAddress CreateForeignServer

(

CreateForeignServerStmt *

stmt

)

Definition at line 861 of file foreigncmds.c.

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

Referenced by ProcessUtilitySlow().

{
    Relation    rel;
    Datum       srvoptions;
    Datum       values[Natts_pg_foreign_server];
    bool        nulls[Natts_pg_foreign_server];
    HeapTuple   tuple;
    Oid         srvId;
    Oid         ownerId;
    AclResult   aclresult;
    ObjectAddress myself;
    ObjectAddress referenced;
    ForeignDataWrapper *fdw;

    rel = heap_open(ForeignServerRelationId, RowExclusiveLock);

    /* For now the owner cannot be specified on create. Use effective user ID. */
    ownerId = GetUserId();

    /*
     * Check that there is no other foreign server by this name. Do nothing if
     * IF NOT EXISTS was enforced.
     */
    if (GetForeignServerByName(stmt->servername, true) != NULL)
    {
        if (stmt->if_not_exists)
        {
            ereport(NOTICE,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("server \"%s\" already exists, skipping",
                            stmt->servername)));
            heap_close(rel, RowExclusiveLock);
            return InvalidObjectAddress;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("server \"%s\" already exists",
                            stmt->servername)));
    }

    /*
     * Check that the FDW exists and that we have USAGE on it. Also get the
     * actual FDW for option validation etc.
     */
    fdw = GetForeignDataWrapperByName(stmt->fdwname, false);

    aclresult = pg_foreign_data_wrapper_aclcheck(fdw->fdwid, ownerId, ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_FDW, fdw->fdwname);

    /*
     * Insert tuple into pg_foreign_server.
     */
    memset(values, 0, sizeof(values));
    memset(nulls, false, sizeof(nulls));

    values[Anum_pg_foreign_server_srvname - 1] =
        DirectFunctionCall1(namein, CStringGetDatum(stmt->servername));
    values[Anum_pg_foreign_server_srvowner - 1] = ObjectIdGetDatum(ownerId);
    values[Anum_pg_foreign_server_srvfdw - 1] = ObjectIdGetDatum(fdw->fdwid);

    /* Add server type if supplied */
    if (stmt->servertype)
        values[Anum_pg_foreign_server_srvtype - 1] =
            CStringGetTextDatum(stmt->servertype);
    else
        nulls[Anum_pg_foreign_server_srvtype - 1] = true;

    /* Add server version if supplied */
    if (stmt->version)
        values[Anum_pg_foreign_server_srvversion - 1] =
            CStringGetTextDatum(stmt->version);
    else
        nulls[Anum_pg_foreign_server_srvversion - 1] = true;

    /* Start with a blank acl */
    nulls[Anum_pg_foreign_server_srvacl - 1] = true;

    /* Add server options */
    srvoptions = transformGenericOptions(ForeignServerRelationId,
                                         PointerGetDatum(NULL),
                                         stmt->options,
                                         fdw->fdwvalidator);

    if (PointerIsValid(DatumGetPointer(srvoptions)))
        values[Anum_pg_foreign_server_srvoptions - 1] = srvoptions;
    else
        nulls[Anum_pg_foreign_server_srvoptions - 1] = true;

    tuple = heap_form_tuple(rel->rd_att, values, nulls);

    srvId = CatalogTupleInsert(rel, tuple);

    heap_freetuple(tuple);

    /* record dependencies */
    myself.classId = ForeignServerRelationId;
    myself.objectId = srvId;
    myself.objectSubId = 0;

    referenced.classId = ForeignDataWrapperRelationId;
    referenced.objectId = fdw->fdwid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

    recordDependencyOnOwner(ForeignServerRelationId, srvId, ownerId);

    /* dependency on extension */
    recordDependencyOnCurrentExtension(&myself, false);

    /* Post creation hook for new foreign server */
    InvokeObjectPostCreateHook(ForeignServerRelationId, srvId, 0);

    heap_close(rel, RowExclusiveLock);

    return myself;
}

CreateForeignTable()

void CreateForeignTable	(	CreateForeignTableStmt *	stmt,
		Oid	relid
	)

Definition at line 1446 of file foreigncmds.c.

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

Referenced by ProcessUtilitySlow().

{
    Relation    ftrel;
    Datum       ftoptions;
    Datum       values[Natts_pg_foreign_table];
    bool        nulls[Natts_pg_foreign_table];
    HeapTuple   tuple;
    AclResult   aclresult;
    ObjectAddress myself;
    ObjectAddress referenced;
    Oid         ownerId;
    ForeignDataWrapper *fdw;
    ForeignServer *server;

    /*
     * Advance command counter to ensure the pg_attribute tuple is visible;
     * the tuple might be updated to add constraints in previous step.
     */
    CommandCounterIncrement();

    ftrel = heap_open(ForeignTableRelationId, RowExclusiveLock);

    /*
     * For now the owner cannot be specified on create. Use effective user ID.
     */
    ownerId = GetUserId();

    /*
     * Check that the foreign server exists and that we have USAGE on it. Also
     * get the actual FDW for option validation etc.
     */
    server = GetForeignServerByName(stmt->servername, false);
    aclresult = pg_foreign_server_aclcheck(server->serverid, ownerId, ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, 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);

    heap_close(ftrel, RowExclusiveLock);
}

CreateFunction()

ObjectAddress CreateFunction	(	ParseState *	pstate,
		CreateFunctionStmt *	stmt
	)

Definition at line 865 of file functioncmds.c.

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

Referenced by ProcessUtilitySlow().

{
    char       *probin_str;
    char       *prosrc_str;
    Oid         prorettype;
    bool        returnsSet;
    char       *language;
    Oid         languageOid;
    Oid         languageValidator;
    Node       *transformDefElem = NULL;
    char       *funcname;
    Oid         namespaceId;
    AclResult   aclresult;
    oidvector  *parameterTypes;
    ArrayType  *allParameterTypes;
    ArrayType  *parameterModes;
    ArrayType  *parameterNames;
    List       *parameterDefaults;
    Oid         variadicArgType;
    List       *trftypes_list = NIL;
    ArrayType  *trftypes;
    Oid         requiredResultType;
    bool        isWindowFunc,
                isStrict,
                security,
                isLeakProof;
    char        volatility;
    ArrayType  *proconfig;
    float4      procost;
    float4      prorows;
    HeapTuple   languageTuple;
    Form_pg_language languageStruct;
    List       *as_clause;
    char        parallel;

    /* Convert list of names to a name and namespace */
    namespaceId = QualifiedNameGetCreationNamespace(stmt->funcname,
                                                    &funcname);

    /* Check we have creation rights in target namespace */
    aclresult = pg_namespace_aclcheck(namespaceId, GetUserId(), ACL_CREATE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_SCHEMA,
                       get_namespace_name(namespaceId));

    /* Set default attributes */
    isWindowFunc = false;
    isStrict = false;
    security = false;
    isLeakProof = false;
    volatility = PROVOLATILE_VOLATILE;
    proconfig = NULL;
    procost = -1;               /* indicates not set */
    prorows = -1;               /* indicates not set */
    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, &parallel);

    /* Look up the language and validate permissions */
    languageTuple = SearchSysCache1(LANGNAME, PointerGetDatum(language));
    if (!HeapTupleIsValid(languageTuple))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("language \"%s\" does not exist", language),
                 (PLTemplateExists(language) ?
                  errhint("Use CREATE EXTENSION to load the language into the database.") : 0)));

    languageOid = HeapTupleGetOid(languageTuple);
    languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);

    if (languageStruct->lanpltrusted)
    {
        /* if trusted language, need USAGE privilege */
        AclResult   aclresult;

        aclresult = pg_language_aclcheck(languageOid, GetUserId(), ACL_USAGE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_LANGUAGE,
                           NameStr(languageStruct->lanname));
    }
    else
    {
        /* if untrusted language, must be superuser */
        if (!superuser())
            aclcheck_error(ACLCHECK_NO_PRIV, OBJECT_LANGUAGE,
                           NameStr(languageStruct->lanname));
    }

    languageValidator = languageStruct->lanvalidator;

    ReleaseSysCache(languageTuple);

    /*
     * Only superuser is allowed to create leakproof functions because
     * leakproof functions can see tuples which have not yet been filtered out
     * by security barrier views or row level security policies.
     */
    if (isLeakProof && !superuser())
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("only superuser can define a leakproof function")));

    if (transformDefElem)
    {
        ListCell   *lc;

        foreach(lc, castNode(List, transformDefElem))
        {
            Oid         typeid = typenameTypeId(NULL,
                                                lfirst_node(TypeName, lc));
            Oid         elt = get_base_element_type(typeid);

            typeid = elt ? elt : typeid;

            get_transform_oid(typeid, languageOid, false);
            trftypes_list = lappend_oid(trftypes_list, typeid);
        }
    }

    /*
     * Convert remaining parameters of CREATE to form wanted by
     * ProcedureCreate.
     */
    interpret_function_parameter_list(pstate,
                                      stmt->parameters,
                                      languageOid,
                                      stmt->is_procedure ? OBJECT_PROCEDURE : OBJECT_FUNCTION,
                                      &parameterTypes,
                                      &allParameterTypes,
                                      &parameterModes,
                                      &parameterNames,
                                      &parameterDefaults,
                                      &variadicArgType,
                                      &requiredResultType);

    if (stmt->is_procedure)
    {
        Assert(!stmt->returnType);
        prorettype = requiredResultType ? requiredResultType : VOIDOID;
        returnsSet = false;
    }
    else if (stmt->returnType)
    {
        /* explicit RETURNS clause */
        compute_return_type(stmt->returnType, languageOid,
                            &prorettype, &returnsSet);
        if (OidIsValid(requiredResultType) && prorettype != requiredResultType)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("function result type must be %s because of OUT parameters",
                            format_type_be(requiredResultType))));
    }
    else if (OidIsValid(requiredResultType))
    {
        /* default RETURNS clause from OUT parameters */
        prorettype = requiredResultType;
        returnsSet = false;
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                 errmsg("function result type must be specified")));
        /* Alternative possibility: default to RETURNS VOID */
        prorettype = VOIDOID;
        returnsSet = false;
    }

    if (list_length(trftypes_list) > 0)
    {
        ListCell   *lc;
        Datum      *arr;
        int         i;

        arr = palloc(list_length(trftypes_list) * sizeof(Datum));
        i = 0;
        foreach(lc, trftypes_list)
            arr[i++] = ObjectIdGetDatum(lfirst_oid(lc));
        trftypes = construct_array(arr, list_length(trftypes_list),
                                   OIDOID, sizeof(Oid), true, 'i');
    }
    else
    {
        /* store SQL NULL instead of empty array */
        trftypes = NULL;
    }

    interpret_AS_clause(languageOid, language, funcname, as_clause,
                        &prosrc_str, &probin_str);

    /*
     * Set default values for COST and ROWS depending on other parameters;
     * reject ROWS if it's not returnsSet.  NB: pg_dump knows these default
     * values, keep it in sync if you change them.
     */
    if (procost < 0)
    {
        /* SQL and PL-language functions are assumed more expensive */
        if (languageOid == INTERNALlanguageId ||
            languageOid == ClanguageId)
            procost = 1;
        else
            procost = 100;
    }
    if (prorows < 0)
    {
        if (returnsSet)
            prorows = 1000;
        else
            prorows = 0;        /* dummy value if not returnsSet */
    }
    else if (!returnsSet)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("ROWS is not applicable when function does not return a set")));

    /*
     * And now that we have all the parameters, and know we're permitted to do
     * so, go ahead and create the function.
     */
    return ProcedureCreate(funcname,
                           namespaceId,
                           stmt->replace,
                           returnsSet,
                           prorettype,
                           GetUserId(),
                           languageOid,
                           languageValidator,
                           prosrc_str,  /* converted to text later */
                           probin_str,  /* converted to text later */
                           stmt->is_procedure ? PROKIND_PROCEDURE : (isWindowFunc ? PROKIND_WINDOW : PROKIND_FUNCTION),
                           security,
                           isLeakProof,
                           isStrict,
                           volatility,
                           parallel,
                           parameterTypes,
                           PointerGetDatum(allParameterTypes),
                           PointerGetDatum(parameterModes),
                           PointerGetDatum(parameterNames),
                           parameterDefaults,
                           PointerGetDatum(trftypes),
                           PointerGetDatum(proconfig),
                           procost,
                           prorows);
}

CreateStatistics()

ObjectAddress CreateStatistics

(

CreateStatsStmt *

stmt

)

Definition at line 55 of file statscmds.c.

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

Referenced by ProcessUtilitySlow().

{
    int16       attnums[STATS_MAX_DIMENSIONS];
    int         numcols = 0;
    char       *namestr;
    NameData    stxname;
    Oid         statoid;
    Oid         namespaceId;
    Oid         stxowner = GetUserId();
    HeapTuple   htup;
    Datum       values[Natts_pg_statistic_ext];
    bool        nulls[Natts_pg_statistic_ext];
    int2vector *stxkeys;
    Relation    statrel;
    Relation    rel = NULL;
    Oid         relid;
    ObjectAddress parentobject,
                myself;
    Datum       types[2];       /* one for each possible type of statistic */
    int         ntypes;
    ArrayType  *stxkind;
    bool        build_ndistinct;
    bool        build_dependencies;
    bool        requested_type = false;
    int         i;
    ListCell   *cell;

    Assert(IsA(stmt, CreateStatsStmt));

    /*
     * Examine the FROM clause.  Currently, we only allow it to be a single
     * simple table, but later we'll probably allow multiple tables and JOIN
     * syntax.  The grammar is already prepared for that, so we have to check
     * here that what we got is what we can support.
     */
    if (list_length(stmt->relations) != 1)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("only a single relation is allowed in CREATE STATISTICS")));

    foreach(cell, stmt->relations)
    {
        Node       *rln = (Node *) lfirst(cell);

        if (!IsA(rln, RangeVar))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("only a single relation is allowed in CREATE STATISTICS")));

        /*
         * CREATE STATISTICS will influence future execution plans but does
         * not interfere with currently executing plans.  So it should be
         * enough to take only ShareUpdateExclusiveLock on relation,
         * conflicting with ANALYZE and other DDL that sets statistical
         * information, but not with normal queries.
         */
        rel = relation_openrv((RangeVar *) rln, ShareUpdateExclusiveLock);

        /* Restrict to allowed relation types */
        if (rel->rd_rel->relkind != RELKIND_RELATION &&
            rel->rd_rel->relkind != RELKIND_MATVIEW &&
            rel->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
            rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("relation \"%s\" is not a table, foreign table, or materialized view",
                            RelationGetRelationName(rel))));

        /* You must own the relation to create stats on it */
        if (!pg_class_ownercheck(RelationGetRelid(rel), stxowner))
            aclcheck_error(ACLCHECK_NOT_OWNER, get_relkind_objtype(rel->rd_rel->relkind),
                           RelationGetRelationName(rel));
    }

    Assert(rel);
    relid = RelationGetRelid(rel);

    /*
     * If the node has a name, split it up and determine creation namespace.
     * If not (a possibility not considered by the grammar, but one which can
     * occur via the "CREATE TABLE ... (LIKE)" command), then we put the
     * object in the same namespace as the relation, and cons up a name for
     * it.
     */
    if (stmt->defnames)
        namespaceId = QualifiedNameGetCreationNamespace(stmt->defnames,
                                                        &namestr);
    else
    {
        namespaceId = RelationGetNamespace(rel);
        namestr = ChooseExtendedStatisticName(RelationGetRelationName(rel),
                                              ChooseExtendedStatisticNameAddition(stmt->exprs),
                                              "stat",
                                              namespaceId);
    }
    namestrcpy(&stxname, namestr);

    /*
     * Deal with the possibility that the statistics object already exists.
     */
    if (SearchSysCacheExists2(STATEXTNAMENSP,
                              CStringGetDatum(namestr),
                              ObjectIdGetDatum(namespaceId)))
    {
        if (stmt->if_not_exists)
        {
            ereport(NOTICE,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("statistics object \"%s\" already exists, skipping",
                            namestr)));
            relation_close(rel, NoLock);
            return InvalidObjectAddress;
        }

        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("statistics object \"%s\" already exists", namestr)));
    }

    /*
     * Currently, we only allow simple column references in the expression
     * list.  That will change someday, and again the grammar already supports
     * it so we have to enforce restrictions here.  For now, we can convert
     * the expression list to a simple array of attnums.  While at it, enforce
     * some constraints.
     */
    foreach(cell, stmt->exprs)
    {
        Node       *expr = (Node *) lfirst(cell);
        ColumnRef  *cref;
        char       *attname;
        HeapTuple   atttuple;
        Form_pg_attribute attForm;
        TypeCacheEntry *type;

        if (!IsA(expr, ColumnRef))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("only simple column references are allowed in CREATE STATISTICS")));
        cref = (ColumnRef *) expr;

        if (list_length(cref->fields) != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("only simple column references are allowed in CREATE STATISTICS")));
        attname = strVal((Value *) linitial(cref->fields));

        atttuple = SearchSysCacheAttName(relid, attname);
        if (!HeapTupleIsValid(atttuple))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" does not exist",
                            attname)));
        attForm = (Form_pg_attribute) GETSTRUCT(atttuple);

        /* Disallow use of system attributes in extended stats */
        if (attForm->attnum <= 0)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("statistics creation on system columns is not supported")));

        /* Disallow data types without a less-than operator */
        type = lookup_type_cache(attForm->atttypid, TYPECACHE_LT_OPR);
        if (type->lt_opr == InvalidOid)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("column \"%s\" cannot be used in statistics because its type %s has no default btree operator class",
                            attname, format_type_be(attForm->atttypid))));

        /* Make sure no more than STATS_MAX_DIMENSIONS columns are used */
        if (numcols >= STATS_MAX_DIMENSIONS)
            ereport(ERROR,
                    (errcode(ERRCODE_TOO_MANY_COLUMNS),
                     errmsg("cannot have more than %d columns in statistics",
                            STATS_MAX_DIMENSIONS)));

        attnums[numcols] = attForm->attnum;
        numcols++;
        ReleaseSysCache(atttuple);
    }

    /*
     * Check that at least two columns were specified in the statement. The
     * upper bound was already checked in the loop above.
     */
    if (numcols < 2)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("extended statistics require at least 2 columns")));

    /*
     * Sort the attnums, which makes detecting duplicates somewhat easier, and
     * it does not hurt (it does not affect the efficiency, unlike for
     * indexes, for example).
     */
    qsort(attnums, numcols, sizeof(int16), compare_int16);

    /*
     * Check for duplicates in the list of columns. The attnums are sorted so
     * just check consecutive elements.
     */
    for (i = 1; i < numcols; i++)
    {
        if (attnums[i] == attnums[i - 1])
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_COLUMN),
                     errmsg("duplicate column name in statistics definition")));
    }

    /* Form an int2vector representation of the sorted column list */
    stxkeys = buildint2vector(attnums, numcols);

    /*
     * Parse the statistics kinds.
     */
    build_ndistinct = false;
    build_dependencies = false;
    foreach(cell, stmt->stat_types)
    {
        char       *type = strVal((Value *) lfirst(cell));

        if (strcmp(type, "ndistinct") == 0)
        {
            build_ndistinct = true;
            requested_type = true;
        }
        else if (strcmp(type, "dependencies") == 0)
        {
            build_dependencies = true;
            requested_type = true;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("unrecognized statistics kind \"%s\"",
                            type)));
    }
    /* If no statistic type was specified, build them all. */
    if (!requested_type)
    {
        build_ndistinct = true;
        build_dependencies = true;
    }

    /* construct the char array of enabled statistic types */
    ntypes = 0;
    if (build_ndistinct)
        types[ntypes++] = CharGetDatum(STATS_EXT_NDISTINCT);
    if (build_dependencies)
        types[ntypes++] = CharGetDatum(STATS_EXT_DEPENDENCIES);
    Assert(ntypes > 0 && ntypes <= lengthof(types));
    stxkind = construct_array(types, ntypes, CHAROID, 1, true, 'c');

    /*
     * Everything seems fine, so let's build the pg_statistic_ext tuple.
     */
    memset(values, 0, sizeof(values));
    memset(nulls, false, sizeof(nulls));
    values[Anum_pg_statistic_ext_stxrelid - 1] = ObjectIdGetDatum(relid);
    values[Anum_pg_statistic_ext_stxname - 1] = NameGetDatum(&stxname);
    values[Anum_pg_statistic_ext_stxnamespace - 1] = ObjectIdGetDatum(namespaceId);
    values[Anum_pg_statistic_ext_stxowner - 1] = ObjectIdGetDatum(stxowner);
    values[Anum_pg_statistic_ext_stxkeys - 1] = PointerGetDatum(stxkeys);
    values[Anum_pg_statistic_ext_stxkind - 1] = PointerGetDatum(stxkind);

    /* no statistics built yet */
    nulls[Anum_pg_statistic_ext_stxndistinct - 1] = true;
    nulls[Anum_pg_statistic_ext_stxdependencies - 1] = true;

    /* insert it into pg_statistic_ext */
    statrel = heap_open(StatisticExtRelationId, RowExclusiveLock);
    htup = heap_form_tuple(statrel->rd_att, values, nulls);
    statoid = CatalogTupleInsert(statrel, htup);
    heap_freetuple(htup);
    relation_close(statrel, RowExclusiveLock);

    /*
     * Invalidate relcache so that others see the new statistics object.
     */
    CacheInvalidateRelcache(rel);

    relation_close(rel, NoLock);

    /*
     * Add an AUTO dependency on each column used in the stats, so that the
     * stats object goes away if any or all of them get dropped.
     */
    ObjectAddressSet(myself, StatisticExtRelationId, statoid);

    for (i = 0; i < numcols; i++)
    {
        ObjectAddressSubSet(parentobject, RelationRelationId, relid, attnums[i]);
        recordDependencyOn(&myself, &parentobject, DEPENDENCY_AUTO);
    }

    /*
     * Also add dependencies on namespace and owner.  These are required
     * because the stats object might have a different namespace and/or owner
     * than the underlying table(s).
     */
    ObjectAddressSet(parentobject, NamespaceRelationId, namespaceId);
    recordDependencyOn(&myself, &parentobject, DEPENDENCY_NORMAL);

    recordDependencyOnOwner(StatisticExtRelationId, statoid, stxowner);

    /*
     * XXX probably there should be a recordDependencyOnCurrentExtension call
     * here too, but we'd have to add support for ALTER EXTENSION ADD/DROP
     * STATISTICS, which is more work than it seems worth.
     */

    /* Add any requested comment */
    if (stmt->stxcomment != NULL)
        CreateComments(statoid, StatisticExtRelationId, 0,
                       stmt->stxcomment);

    /* Return stats object's address */
    return myself;
}

CreateTransform()

ObjectAddress CreateTransform

(

CreateTransformStmt *

stmt

)

Definition at line 1801 of file functioncmds.c.

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

Referenced by ProcessUtilitySlow().

{
    Oid         typeid;
    char        typtype;
    Oid         langid;
    Oid         fromsqlfuncid;
    Oid         tosqlfuncid;
    AclResult   aclresult;
    Form_pg_proc procstruct;
    Datum       values[Natts_pg_transform];
    bool        nulls[Natts_pg_transform];
    bool        replaces[Natts_pg_transform];
    Oid         transformid;
    HeapTuple   tuple;
    HeapTuple   newtuple;
    Relation    relation;
    ObjectAddress myself,
                referenced;
    bool        is_replace;

    /*
     * Get the type
     */
    typeid = typenameTypeId(NULL, stmt->type_name);
    typtype = get_typtype(typeid);

    if (typtype == TYPTYPE_PSEUDO)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("data type %s is a pseudo-type",
                        TypeNameToString(stmt->type_name))));

    if (typtype == TYPTYPE_DOMAIN)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("data type %s is a domain",
                        TypeNameToString(stmt->type_name))));

    if (!pg_type_ownercheck(typeid, GetUserId()))
        aclcheck_error_type(ACLCHECK_NOT_OWNER, typeid);

    aclresult = pg_type_aclcheck(typeid, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, typeid);

    /*
     * Get the language
     */
    langid = get_language_oid(stmt->lang, false);

    aclresult = pg_language_aclcheck(langid, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error(aclresult, OBJECT_LANGUAGE, stmt->lang);

    /*
     * Get the functions
     */
    if (stmt->fromsql)
    {
        fromsqlfuncid = LookupFuncWithArgs(OBJECT_FUNCTION, stmt->fromsql, false);

        if (!pg_proc_ownercheck(fromsqlfuncid, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, NameListToString(stmt->fromsql->objname));

        aclresult = pg_proc_aclcheck(fromsqlfuncid, GetUserId(), ACL_EXECUTE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_FUNCTION, NameListToString(stmt->fromsql->objname));

        tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(fromsqlfuncid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for function %u", fromsqlfuncid);
        procstruct = (Form_pg_proc) GETSTRUCT(tuple);
        if (procstruct->prorettype != INTERNALOID)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("return data type of FROM SQL function must be %s",
                            "internal")));
        check_transform_function(procstruct);
        ReleaseSysCache(tuple);
    }
    else
        fromsqlfuncid = InvalidOid;

    if (stmt->tosql)
    {
        tosqlfuncid = LookupFuncWithArgs(OBJECT_FUNCTION, stmt->tosql, false);

        if (!pg_proc_ownercheck(tosqlfuncid, GetUserId()))
            aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, NameListToString(stmt->tosql->objname));

        aclresult = pg_proc_aclcheck(tosqlfuncid, GetUserId(), ACL_EXECUTE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error(aclresult, OBJECT_FUNCTION, NameListToString(stmt->tosql->objname));

        tuple = SearchSysCache1(PROCOID, ObjectIdGetDatum(tosqlfuncid));
        if (!HeapTupleIsValid(tuple))
            elog(ERROR, "cache lookup failed for function %u", tosqlfuncid);
        procstruct = (Form_pg_proc) GETSTRUCT(tuple);
        if (procstruct->prorettype != typeid)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("return data type of TO SQL function must be the transform data type")));
        check_transform_function(procstruct);
        ReleaseSysCache(tuple);
    }
    else
        tosqlfuncid = InvalidOid;

    /*
     * Ready to go
     */
    values[Anum_pg_transform_trftype - 1] = ObjectIdGetDatum(typeid);
    values[Anum_pg_transform_trflang - 1] = ObjectIdGetDatum(langid);
    values[Anum_pg_transform_trffromsql - 1] = ObjectIdGetDatum(fromsqlfuncid);
    values[Anum_pg_transform_trftosql - 1] = ObjectIdGetDatum(tosqlfuncid);

    MemSet(nulls, false, sizeof(nulls));

    relation = heap_open(TransformRelationId, RowExclusiveLock);

    tuple = SearchSysCache2(TRFTYPELANG,
                            ObjectIdGetDatum(typeid),
                            ObjectIdGetDatum(langid));
    if (HeapTupleIsValid(tuple))
    {
        if (!stmt->replace)
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("transform for type %s language \"%s\" already exists",
                            format_type_be(typeid),
                            stmt->lang)));

        MemSet(replaces, false, sizeof(replaces));
        replaces[Anum_pg_transform_trffromsql - 1] = true;
        replaces[Anum_pg_transform_trftosql - 1] = true;

        newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values, nulls, replaces);
        CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);

        transformid = HeapTupleGetOid(tuple);
        ReleaseSysCache(tuple);
        is_replace = true;
    }
    else
    {
        newtuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
        transformid = CatalogTupleInsert(relation, newtuple);
        is_replace = false;
    }

    if (is_replace)
        deleteDependencyRecordsFor(TransformRelationId, transformid, true);

    /* make dependency entries */
    myself.classId = TransformRelationId;
    myself.objectId = transformid;
    myself.objectSubId = 0;

    /* dependency on language */
    referenced.classId = LanguageRelationId;
    referenced.objectId = langid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

    /* dependency on type */
    referenced.classId = TypeRelationId;
    referenced.objectId = typeid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

    /* dependencies on functions */
    if (OidIsValid(fromsqlfuncid))
    {
        referenced.classId = ProcedureRelationId;
        referenced.objectId = fromsqlfuncid;
        referenced.objectSubId = 0;
        recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
    }
    if (OidIsValid(tosqlfuncid))
    {
        referenced.classId = ProcedureRelationId;
        referenced.objectId = tosqlfuncid;
        referenced.objectSubId = 0;
        recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
    }

    /* dependency on extension */
    recordDependencyOnCurrentExtension(&myself, is_replace);

    /* Post creation hook for new transform */
    InvokeObjectPostCreateHook(TransformRelationId, transformid, 0);

    heap_freetuple(newtuple);

    heap_close(relation, RowExclusiveLock);

    return myself;
}

CreateUserMapping()

ObjectAddress CreateUserMapping

(

CreateUserMappingStmt *

stmt

)

Definition at line 1135 of file foreigncmds.c.

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

Referenced by ProcessUtilitySlow().

{
    Relation    rel;
    Datum       useoptions;
    Datum       values[Natts_pg_user_mapping];
    bool        nulls[Natts_pg_user_mapping];
    HeapTuple   tuple;
    Oid         useId;
    Oid         umId;
    ObjectAddress myself;
    ObjectAddress referenced;
    ForeignServer *srv;
    ForeignDataWrapper *fdw;
    RoleSpec   *role = (RoleSpec *) stmt->user;

    rel = heap_open(UserMappingRelationId, RowExclusiveLock);

    if (role->roletype == ROLESPEC_PUBLIC)
        useId = ACL_ID_PUBLIC;
    else
        useId = get_rolespec_oid(stmt->user, false);

    /* Check that the server exists. */
    srv = GetForeignServerByName(stmt->servername, false);

    user_mapping_ddl_aclcheck(useId, srv->serverid, stmt->servername);

    /*
     * Check that the user mapping is unique within server.
     */
    umId = GetSysCacheOid2(USERMAPPINGUSERSERVER,
                           ObjectIdGetDatum(useId),
                           ObjectIdGetDatum(srv->serverid));

    if (OidIsValid(umId))
    {
        if (stmt->if_not_exists)
        {
            ereport(NOTICE,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("user mapping for \"%s\" already exists for server %s, skipping",
                            MappingUserName(useId),
                            stmt->servername)));

            heap_close(rel, RowExclusiveLock);
            return InvalidObjectAddress;
        }
        else
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("user mapping for \"%s\" already exists for server %s",
                            MappingUserName(useId),
                            stmt->servername)));
    }

    fdw = GetForeignDataWrapper(srv->fdwid);

    /*
     * Insert tuple into pg_user_mapping.
     */
    memset(values, 0, sizeof(values));
    memset(nulls, false, sizeof(nulls));

    values[Anum_pg_user_mapping_umuser - 1] = ObjectIdGetDatum(useId);
    values[Anum_pg_user_mapping_umserver - 1] = ObjectIdGetDatum(srv->serverid);

    /* Add user options */
    useoptions = transformGenericOptions(UserMappingRelationId,
                                         PointerGetDatum(NULL),
                                         stmt->options,
                                         fdw->fdwvalidator);

    if (PointerIsValid(DatumGetPointer(useoptions)))
        values[Anum_pg_user_mapping_umoptions - 1] = useoptions;
    else
        nulls[Anum_pg_user_mapping_umoptions - 1] = true;

    tuple = heap_form_tuple(rel->rd_att, values, nulls);

    umId = CatalogTupleInsert(rel, tuple);

    heap_freetuple(tuple);

    /* Add dependency on the server */
    myself.classId = UserMappingRelationId;
    myself.objectId = umId;
    myself.objectSubId = 0;

    referenced.classId = ForeignServerRelationId;
    referenced.objectId = srv->serverid;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);

    if (OidIsValid(useId))
    {
        /* Record the mapped user dependency */
        recordDependencyOnOwner(UserMappingRelationId, umId, useId);
    }

    /* dependency on extension */
    recordDependencyOnCurrentExtension(&myself, false);

    /* Post creation hook for new user mapping */
    InvokeObjectPostCreateHook(UserMappingRelationId, umId, 0);

    heap_close(rel, RowExclusiveLock);

    return myself;
}

defGetBoolean()

bool defGetBoolean

(

DefElem *

def

)

Definition at line 111 of file define.c.

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

Referenced by AlterDatabase(), apply_server_options(), apply_table_options(), createdb(), CreateExtension(), DefineAggregate(), DefineOperator(), DefineType(), dintdict_init(), dsimple_init(), dsynonym_init(), dxsyn_init(), ExplainQuery(), file_fdw_validator(), get_file_fdw_attribute_options(), GetCommandLogLevel(), interpretOidsOption(), parse_subscription_options(), parseCreateReplSlotOptions(), postgres_fdw_validator(), postgresImportForeignSchema(), postgresIsForeignRelUpdatable(), and ProcessCopyOptions().

{
    /*
     * If no parameter given, assume "true" is meant.
     */
    if (def->arg == NULL)
        return true;

    /*
     * Allow 0, 1, "true", "false", "on", "off"
     */
    switch (nodeTag(def->arg))
    {
        case T_Integer:
            switch (intVal(def->arg))
            {
                case 0:
                    return false;
                case 1:
                    return true;
                default:
                    /* otherwise, error out below */
                    break;
            }
            break;
        default:
            {
                char       *sval = defGetString(def);

                /*
                 * The set of strings accepted here should match up with the
                 * grammar's opt_boolean production.
                 */
                if (pg_strcasecmp(sval, "true") == 0)
                    return true;
                if (pg_strcasecmp(sval, "false") == 0)
                    return false;
                if (pg_strcasecmp(sval, "on") == 0)
                    return true;
                if (pg_strcasecmp(sval, "off") == 0)
                    return false;
            }
            break;
    }
    ereport(ERROR,
            (errcode(ERRCODE_SYNTAX_ERROR),
             errmsg("%s requires a Boolean value",
                    def->defname)));
    return false;               /* keep compiler quiet */
}

defGetInt32()

int32 defGetInt32

(

DefElem *

def

)

Definition at line 166 of file define.c.

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

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

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

defGetInt64()

int64 defGetInt64

(

DefElem *

def

)

Definition at line 190 of file define.c.

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

Referenced by init_params().

{
    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(strVal(def->arg))));
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("%s requires a numeric value",
                            def->defname)));
    }
    return 0;                   /* keep compiler quiet */
}

defGetNumeric()

double defGetNumeric

(

DefElem *

def

)

Definition at line 85 of file define.c.

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

Referenced by AlterFunction(), and compute_function_attributes().

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

defGetQualifiedName()

List* defGetQualifiedName

(

DefElem *

def

)

Definition at line 223 of file define.c.

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

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

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

defGetString()

char* defGetString

(

DefElem *

def

)

Definition at line 49 of file define.c.

References DefElem::arg, DefElem::defname, elog, ereport, errcode(), errmsg(), ERROR, intVal, NameListToString(), nodeTag, psprintf(), pstrdup(), strVal, T_A_Star, T_Float, T_Integer, T_List, T_String, T_TypeName, and TypeNameToString().

Referenced by AlterDatabase(), apply_server_options(), apply_table_options(), check_selective_binary_conversion(), createdb(), CreateExtension(), defGetBoolean(), defGetTypeLength(), DefineAggregate(), DefineCollation(), DefineType(), deparseAnalyzeSql(), deparseColumnRef(), deparseRelation(), dintdict_init(), dispell_init(), dsimple_init(), dsnowball_init(), dsynonym_init(), dxsyn_init(), ExplainQuery(), ExplainResultDesc(), ExtractConnectionOptions(), extractModify(), file_fdw_validator(), fileGetOptions(), optionListToArray(), parse_publication_options(), parse_subscription_options(), postgres_fdw_validator(), postgresAcquireSampleRowsFunc(), ProcessCopyOptions(), prsd_headline(), serialize_deflist(), thesaurus_init(), transformRelOptions(), and unaccent_init().

{