pg_aggregate.h File Reference

#include "catalog/genbki.h"
#include "catalog/pg_aggregate_d.h"
#include "catalog/objectaddress.h"
#include "nodes/pg_list.h"

Include dependency graph for pg_aggregate.h:

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

Go to the source code of this file.

Functions
BEGIN_CATALOG_STRUCT	CATALOG (pg_aggregate, 2600, AggregateRelationId)
	DECLARE_TOAST (pg_aggregate, 4159, 4160)
	DECLARE_UNIQUE_INDEX_PKEY (pg_aggregate_fnoid_index, 2650, AggregateFnoidIndexId, pg_aggregate, btree(aggfnoid oid_ops))
	MAKE_SYSCACHE (AGGFNOID, pg_aggregate_fnoid_index, 16)
ObjectAddress	AggregateCreate (const char *aggName, Oid aggNamespace, bool replace, char aggKind, int numArgs, int numDirectArgs, oidvector *parameterTypes, Datum allParameterTypes, Datum parameterModes, Datum parameterNames, List *parameterDefaults, Oid variadicArgType, List *aggtransfnName, List *aggfinalfnName, List *aggcombinefnName, List *aggserialfnName, List *aggdeserialfnName, List *aggmtransfnName, List *aggminvtransfnName, List *aggmfinalfnName, bool finalfnExtraArgs, bool mfinalfnExtraArgs, char finalfnModify, char mfinalfnModify, List *aggsortopName, Oid aggTransType, int32 aggTransSpace, Oid aggmTransType, int32 aggmTransSpace, const char *agginitval, const char *aggminitval, char proparallel)

Variables
END_CATALOG_STRUCT typedef FormData_pg_aggregate *	Form_pg_aggregate
	FormData_pg_aggregate

Function Documentation

AggregateCreate()

ObjectAddress AggregateCreate ( const char *  aggName, Oid  aggNamespace, bool  replace, char  aggKind, int  numArgs, int  numDirectArgs, oidvector *  parameterTypes, Datum  allParameterTypes, Datum  parameterModes, Datum  parameterNames, List *  parameterDefaults, Oid  variadicArgType, List *  aggtransfnName, List *  aggfinalfnName, List *  aggcombinefnName, List *  aggserialfnName, List *  aggdeserialfnName, List *  aggmtransfnName, List *  aggminvtransfnName, List *  aggmfinalfnName, bool  finalfnExtraArgs, bool  mfinalfnExtraArgs, char  finalfnModify, char  mfinalfnModify, List *  aggsortopName, Oid  aggTransType, int32  aggTransSpace, Oid  aggmTransType, int32  aggmTransSpace, const char *  agginitval, const char *  aggminitval, char  proparallel  )

extern

Definition at line 46 of file pg_aggregate.c.

{
    Relation    aggdesc;
    HeapTuple   tup;
    HeapTuple   oldtup;
    bool        nulls[Natts_pg_aggregate];
    Datum       values[Natts_pg_aggregate];
    bool        replaces[Natts_pg_aggregate];
    Form_pg_proc proc;
    Oid         transfn;
    Oid         finalfn = InvalidOid;   /* can be omitted */
    Oid         combinefn = InvalidOid; /* can be omitted */
    Oid         serialfn = InvalidOid;  /* can be omitted */
    Oid         deserialfn = InvalidOid;    /* can be omitted */
    Oid         mtransfn = InvalidOid;  /* can be omitted */
    Oid         minvtransfn = InvalidOid;   /* can be omitted */
    Oid         mfinalfn = InvalidOid;  /* can be omitted */
    Oid         sortop = InvalidOid;    /* can be omitted */
    Oid        *aggArgTypes = parameterTypes->values;
    bool        mtransIsStrict = false;
    Oid         rettype;
    Oid         finaltype;
    Oid         fnArgs[FUNC_MAX_ARGS];
    int         nargs_transfn;
    int         nargs_finalfn;
    Oid         procOid;
    TupleDesc   tupDesc;
    char       *detailmsg;
    int         i;
    ObjectAddress myself,
                referenced;
    ObjectAddresses *addrs;
    AclResult   aclresult;
 
    /* sanity checks (caller should have caught these) */
    if (!aggName)
        elog(ERROR, "no aggregate name supplied");
 
    if (!aggtransfnName)
        elog(ERROR, "aggregate must have a transition function");
 
    if (numDirectArgs < 0 || numDirectArgs > numArgs)
        elog(ERROR, "incorrect number of direct arguments for aggregate");
 
    /*
     * Aggregates can have at most FUNC_MAX_ARGS-1 args, else the transfn
     * and/or finalfn will be unrepresentable in pg_proc.  We must check now
     * to protect fixed-size arrays here and possibly in called functions.
     */
    if (numArgs < 0 || numArgs > FUNC_MAX_ARGS - 1)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                 errmsg_plural("aggregates cannot have more than %d argument",
                               "aggregates cannot have more than %d arguments",
                               FUNC_MAX_ARGS - 1,
                               FUNC_MAX_ARGS - 1)));
 
    /*
     * If transtype is polymorphic, must have polymorphic argument also; else
     * we will have no way to deduce the actual transtype.
     */
    detailmsg = check_valid_polymorphic_signature(aggTransType,
                                                  aggArgTypes,
                                                  numArgs);
    if (detailmsg)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                 errmsg("cannot determine transition data type"),
                 errdetail_internal("%s", detailmsg)));
 
    /*
     * Likewise for moving-aggregate transtype, if any
     */
    if (OidIsValid(aggmTransType))
    {
        detailmsg = check_valid_polymorphic_signature(aggmTransType,
                                                      aggArgTypes,
                                                      numArgs);
        if (detailmsg)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("cannot determine transition data type"),
                     errdetail_internal("%s", detailmsg)));
    }
 
    /*
     * An ordered-set aggregate that is VARIADIC must be VARIADIC ANY.  In
     * principle we could support regular variadic types, but it would make
     * things much more complicated because we'd have to assemble the correct
     * subsets of arguments into array values.  Since no standard aggregates
     * have use for such a case, we aren't bothering for now.
     */
    if (AGGKIND_IS_ORDERED_SET(aggKind) && OidIsValid(variadicArgType) &&
        variadicArgType != ANYOID)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("a variadic ordered-set aggregate must use VARIADIC type ANY")));
 
    /*
     * If it's a hypothetical-set aggregate, there must be at least as many
     * direct arguments as aggregated ones, and the last N direct arguments
     * must match the aggregated ones in type.  (We have to check this again
     * when the aggregate is called, in case ANY is involved, but it makes
     * sense to reject the aggregate definition now if the declared arg types
     * don't match up.)  It's unconditionally OK if numDirectArgs == numArgs,
     * indicating that the grammar merged identical VARIADIC entries from both
     * lists.  Otherwise, if the agg is VARIADIC, then we had VARIADIC only on
     * the aggregated side, which is not OK.  Otherwise, insist on the last N
     * parameter types on each side matching exactly.
     */
    if (aggKind == AGGKIND_HYPOTHETICAL &&
        numDirectArgs < numArgs)
    {
        int         numAggregatedArgs = numArgs - numDirectArgs;
 
        if (OidIsValid(variadicArgType) ||
            numDirectArgs < numAggregatedArgs ||
            memcmp(aggArgTypes + (numDirectArgs - numAggregatedArgs),
                   aggArgTypes + numDirectArgs,
                   numAggregatedArgs * sizeof(Oid)) != 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("a hypothetical-set aggregate must have direct arguments matching its aggregated arguments")));
    }
 
    /*
     * Find the transfn.  For ordinary aggs, it takes the transtype plus all
     * aggregate arguments.  For ordered-set aggs, it takes the transtype plus
     * all aggregated args, but not direct args.  However, we have to treat
     * specially the case where a trailing VARIADIC item is considered to
     * cover both direct and aggregated args.
     */
    if (AGGKIND_IS_ORDERED_SET(aggKind))
    {
        if (numDirectArgs < numArgs)
            nargs_transfn = numArgs - numDirectArgs + 1;
        else
        {
            /* special case with VARIADIC last arg */
            Assert(variadicArgType != InvalidOid);
            nargs_transfn = 2;
        }
        fnArgs[0] = aggTransType;
        memcpy(fnArgs + 1, aggArgTypes + (numArgs - (nargs_transfn - 1)),
               (nargs_transfn - 1) * sizeof(Oid));
    }
    else
    {
        nargs_transfn = numArgs + 1;
        fnArgs[0] = aggTransType;
        memcpy(fnArgs + 1, aggArgTypes, numArgs * sizeof(Oid));
    }
    transfn = lookup_agg_function(aggtransfnName, nargs_transfn,
                                  fnArgs, variadicArgType,
                                  &rettype);
 
    /*
     * Return type of transfn (possibly after refinement by
     * enforce_generic_type_consistency, if transtype isn't polymorphic) must
     * exactly match declared transtype.
     *
     * In the non-polymorphic-transtype case, it might be okay to allow a
     * rettype that's binary-coercible to transtype, but I'm not quite
     * convinced that it's either safe or useful.  When transtype is
     * polymorphic we *must* demand exact equality.
     */
    if (rettype != aggTransType)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("return type of transition function %s is not %s",
                        NameListToString(aggtransfnName),
                        format_type_be(aggTransType))));
 
    tup = SearchSysCache1(PROCOID, ObjectIdGetDatum(transfn));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for function %u", transfn);
    proc = (Form_pg_proc) GETSTRUCT(tup);
 
    /*
     * If the transfn is strict and the initval is NULL, make sure first input
     * type and transtype are the same (or at least binary-compatible), so
     * that it's OK to use the first input value as the initial transValue.
     */
    if (proc->proisstrict && agginitval == NULL)
    {
        if (numArgs < 1 ||
            !IsBinaryCoercible(aggArgTypes[0], aggTransType))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("must not omit initial value when transition function is strict and transition type is not compatible with input type")));
    }
 
    ReleaseSysCache(tup);
 
    /* handle moving-aggregate transfn, if supplied */
    if (aggmtransfnName)
    {
        /*
         * The arguments are the same as for the regular transfn, except that
         * the transition data type might be different.  So re-use the fnArgs
         * values set up above, except for that one.
         */
        Assert(OidIsValid(aggmTransType));
        fnArgs[0] = aggmTransType;
 
        mtransfn = lookup_agg_function(aggmtransfnName, nargs_transfn,
                                       fnArgs, variadicArgType,
                                       &rettype);
 
        /* As above, return type must exactly match declared mtranstype. */
        if (rettype != aggmTransType)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("return type of transition function %s is not %s",
                            NameListToString(aggmtransfnName),
                            format_type_be(aggmTransType))));
 
        tup = SearchSysCache1(PROCOID, ObjectIdGetDatum(mtransfn));
        if (!HeapTupleIsValid(tup))
            elog(ERROR, "cache lookup failed for function %u", mtransfn);
        proc = (Form_pg_proc) GETSTRUCT(tup);
 
        /*
         * If the mtransfn is strict and the minitval is NULL, check first
         * input type and mtranstype are binary-compatible.
         */
        if (proc->proisstrict && aggminitval == NULL)
        {
            if (numArgs < 1 ||
                !IsBinaryCoercible(aggArgTypes[0], aggmTransType))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("must not omit initial value when transition function is strict and transition type is not compatible with input type")));
        }
 
        /* Remember if mtransfn is strict; we may need this below */
        mtransIsStrict = proc->proisstrict;
 
        ReleaseSysCache(tup);
    }
 
    /* handle minvtransfn, if supplied */
    if (aggminvtransfnName)
    {
        /*
         * This must have the same number of arguments with the same types as
         * the forward transition function, so just re-use the fnArgs data.
         */
        Assert(aggmtransfnName);
 
        minvtransfn = lookup_agg_function(aggminvtransfnName, nargs_transfn,
                                          fnArgs, variadicArgType,
                                          &rettype);
 
        /* As above, return type must exactly match declared mtranstype. */
        if (rettype != aggmTransType)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("return type of inverse transition function %s is not %s",
                            NameListToString(aggminvtransfnName),
                            format_type_be(aggmTransType))));
 
        tup = SearchSysCache1(PROCOID, ObjectIdGetDatum(minvtransfn));
        if (!HeapTupleIsValid(tup))
            elog(ERROR, "cache lookup failed for function %u", minvtransfn);
        proc = (Form_pg_proc) GETSTRUCT(tup);
 
        /*
         * We require the strictness settings of the forward and inverse
         * transition functions to agree.  This saves having to handle
         * assorted special cases at execution time.
         */
        if (proc->proisstrict != mtransIsStrict)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("strictness of aggregate's forward and inverse transition functions must match")));
 
        ReleaseSysCache(tup);
    }
 
    /* handle finalfn, if supplied */
    if (aggfinalfnName)
    {
        /*
         * If finalfnExtraArgs is specified, the transfn takes the transtype
         * plus all args; otherwise, it just takes the transtype plus any
         * direct args.  (Non-direct args are useless at runtime, and are
         * actually passed as NULLs, but we may need them in the function
         * signature to allow resolution of a polymorphic agg's result type.)
         */
        Oid         ffnVariadicArgType = variadicArgType;
 
        fnArgs[0] = aggTransType;
        memcpy(fnArgs + 1, aggArgTypes, numArgs * sizeof(Oid));
        if (finalfnExtraArgs)
            nargs_finalfn = numArgs + 1;
        else
        {
            nargs_finalfn = numDirectArgs + 1;
            if (numDirectArgs < numArgs)
            {
                /* variadic argument doesn't affect finalfn */
                ffnVariadicArgType = InvalidOid;
            }
        }
 
        finalfn = lookup_agg_function(aggfinalfnName, nargs_finalfn,
                                      fnArgs, ffnVariadicArgType,
                                      &finaltype);
 
        /*
         * When finalfnExtraArgs is specified, the finalfn will certainly be
         * passed at least one null argument, so complain if it's strict.
         * Nothing bad would happen at runtime (you'd just get a null result),
         * but it's surely not what the user wants, so let's complain now.
         */
        if (finalfnExtraArgs && func_strict(finalfn))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("final function with extra arguments must not be declared STRICT")));
    }
    else
    {
        /*
         * If no finalfn, aggregate result type is type of the state value
         */
        finaltype = aggTransType;
    }
    Assert(OidIsValid(finaltype));
 
    /* handle the combinefn, if supplied */
    if (aggcombinefnName)
    {
        Oid         combineType;
 
        /*
         * Combine function must have 2 arguments, each of which is the trans
         * type.  VARIADIC doesn't affect it.
         */
        fnArgs[0] = aggTransType;
        fnArgs[1] = aggTransType;
 
        combinefn = lookup_agg_function(aggcombinefnName, 2,
                                        fnArgs, InvalidOid,
                                        &combineType);
 
        /* Ensure the return type matches the aggregate's trans type */
        if (combineType != aggTransType)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("return type of combine function %s is not %s",
                            NameListToString(aggcombinefnName),
                            format_type_be(aggTransType))));
 
        /*
         * A combine function to combine INTERNAL states must accept nulls and
         * ensure that the returned state is in the correct memory context. We
         * cannot directly check the latter, but we can check the former.
         */
        if (aggTransType == INTERNALOID && func_strict(combinefn))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("combine function with transition type %s must not be declared STRICT",
                            format_type_be(aggTransType))));
    }
 
    /*
     * Validate the serialization function, if present.
     */
    if (aggserialfnName)
    {
        /* signature is always serialize(internal) returns bytea */
        fnArgs[0] = INTERNALOID;
 
        serialfn = lookup_agg_function(aggserialfnName, 1,
                                       fnArgs, InvalidOid,
                                       &rettype);
 
        if (rettype != BYTEAOID)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("return type of serialization function %s is not %s",
                            NameListToString(aggserialfnName),
                            format_type_be(BYTEAOID))));
    }
 
    /*
     * Validate the deserialization function, if present.
     */
    if (aggdeserialfnName)
    {
        /* signature is always deserialize(bytea, internal) returns internal */
        fnArgs[0] = BYTEAOID;
        fnArgs[1] = INTERNALOID;    /* dummy argument for type safety */
 
        deserialfn = lookup_agg_function(aggdeserialfnName, 2,
                                         fnArgs, InvalidOid,
                                         &rettype);
 
        if (rettype != INTERNALOID)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("return type of deserialization function %s is not %s",
                            NameListToString(aggdeserialfnName),
                            format_type_be(INTERNALOID))));
    }
 
    /*
     * If finaltype (i.e. aggregate return type) is polymorphic, inputs must
     * be polymorphic also, else parser will fail to deduce result type.
     * (Note: given the previous test on transtype and inputs, this cannot
     * happen, unless someone has snuck a finalfn definition into the catalogs
     * that itself violates the rule against polymorphic result with no
     * polymorphic input.)
     */
    detailmsg = check_valid_polymorphic_signature(finaltype,
                                                  aggArgTypes,
                                                  numArgs);
    if (detailmsg)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("cannot determine result data type"),
                 errdetail_internal("%s", detailmsg)));
 
    /*
     * Also, the return type can't be INTERNAL unless there's at least one
     * INTERNAL argument.  This is the same type-safety restriction we enforce
     * for regular functions, but at the level of aggregates.  We must test
     * this explicitly because we allow INTERNAL as the transtype.
     */
    detailmsg = check_valid_internal_signature(finaltype,
                                               aggArgTypes,
                                               numArgs);
    if (detailmsg)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                 errmsg("unsafe use of pseudo-type \"internal\""),
                 errdetail_internal("%s", detailmsg)));
 
    /*
     * If a moving-aggregate implementation is supplied, look up its finalfn
     * if any, and check that the implied aggregate result type matches the
     * plain implementation.
     */
    if (OidIsValid(aggmTransType))
    {
        /* handle finalfn, if supplied */
        if (aggmfinalfnName)
        {
            /*
             * The arguments are figured the same way as for the regular
             * finalfn, but using aggmTransType and mfinalfnExtraArgs.
             */
            Oid         ffnVariadicArgType = variadicArgType;
 
            fnArgs[0] = aggmTransType;
            memcpy(fnArgs + 1, aggArgTypes, numArgs * sizeof(Oid));
            if (mfinalfnExtraArgs)
                nargs_finalfn = numArgs + 1;
            else
            {
                nargs_finalfn = numDirectArgs + 1;
                if (numDirectArgs < numArgs)
                {
                    /* variadic argument doesn't affect finalfn */
                    ffnVariadicArgType = InvalidOid;
                }
            }
 
            mfinalfn = lookup_agg_function(aggmfinalfnName, nargs_finalfn,
                                           fnArgs, ffnVariadicArgType,
                                           &rettype);
 
            /* As above, check strictness if mfinalfnExtraArgs is given */
            if (mfinalfnExtraArgs && func_strict(mfinalfn))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                         errmsg("final function with extra arguments must not be declared STRICT")));
        }
        else
        {
            /*
             * If no finalfn, aggregate result type is type of the state value
             */
            rettype = aggmTransType;
        }
        Assert(OidIsValid(rettype));
        if (rettype != finaltype)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("moving-aggregate implementation returns type %s, but plain implementation returns type %s",
                            format_type_be(rettype),
                            format_type_be(finaltype))));
    }
 
    /* handle sortop, if supplied */
    if (aggsortopName)
    {
        if (numArgs != 1)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("sort operator can only be specified for single-argument aggregates")));
        sortop = LookupOperName(NULL, aggsortopName,
                                aggArgTypes[0], aggArgTypes[0],
                                false, -1);
    }
 
    /*
     * permission checks on used types
     */
    for (i = 0; i < numArgs; i++)
    {
        aclresult = object_aclcheck(TypeRelationId, aggArgTypes[i], GetUserId(), ACL_USAGE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error_type(aclresult, aggArgTypes[i]);
    }
 
    aclresult = object_aclcheck(TypeRelationId, aggTransType, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, aggTransType);
 
    if (OidIsValid(aggmTransType))
    {
        aclresult = object_aclcheck(TypeRelationId, aggmTransType, GetUserId(), ACL_USAGE);
        if (aclresult != ACLCHECK_OK)
            aclcheck_error_type(aclresult, aggmTransType);
    }
 
    aclresult = object_aclcheck(TypeRelationId, finaltype, GetUserId(), ACL_USAGE);
    if (aclresult != ACLCHECK_OK)
        aclcheck_error_type(aclresult, finaltype);
 
 
    /*
     * Everything looks okay.  Try to create the pg_proc entry for the
     * aggregate.  (This could fail if there's already a conflicting entry.)
     */
 
    myself = ProcedureCreate(aggName,
                             aggNamespace,
                             replace,   /* maybe replacement */
                             false, /* doesn't return a set */
                             finaltype, /* returnType */
                             GetUserId(),   /* proowner */
                             INTERNALlanguageId,    /* languageObjectId */
                             InvalidOid,    /* no validator */
                             "aggregate_dummy", /* placeholder (no such proc) */
                             NULL,  /* probin */
                             NULL,  /* prosqlbody */
                             PROKIND_AGGREGATE,
                             false, /* security invoker (currently not
                                     * definable for agg) */
                             false, /* isLeakProof */
                             false, /* isStrict (not needed for agg) */
                             PROVOLATILE_IMMUTABLE, /* volatility (not needed
                                                     * for agg) */
                             proparallel,
                             parameterTypes,    /* paramTypes */
                             allParameterTypes, /* allParamTypes */
                             parameterModes,    /* parameterModes */
                             parameterNames,    /* parameterNames */
                             parameterDefaults, /* parameterDefaults */
                             PointerGetDatum(NULL), /* trftypes */
                             NIL,   /* trfoids */
                             PointerGetDatum(NULL), /* proconfig */
                             InvalidOid,    /* no prosupport */
                             1, /* procost */
                             0);    /* prorows */
    procOid = myself.objectId;
 
    /*
     * Okay to create the pg_aggregate entry.
     */
    aggdesc = table_open(AggregateRelationId, RowExclusiveLock);
    tupDesc = aggdesc->rd_att;
 
    /* initialize nulls and values */
    for (i = 0; i < Natts_pg_aggregate; i++)
    {
        nulls[i] = false;
        values[i] = (Datum) 0;
        replaces[i] = true;
    }
    values[Anum_pg_aggregate_aggfnoid - 1] = ObjectIdGetDatum(procOid);
    values[Anum_pg_aggregate_aggkind - 1] = CharGetDatum(aggKind);
    values[Anum_pg_aggregate_aggnumdirectargs - 1] = Int16GetDatum(numDirectArgs);
    values[Anum_pg_aggregate_aggtransfn - 1] = ObjectIdGetDatum(transfn);
    values[Anum_pg_aggregate_aggfinalfn - 1] = ObjectIdGetDatum(finalfn);
    values[Anum_pg_aggregate_aggcombinefn - 1] = ObjectIdGetDatum(combinefn);
    values[Anum_pg_aggregate_aggserialfn - 1] = ObjectIdGetDatum(serialfn);
    values[Anum_pg_aggregate_aggdeserialfn - 1] = ObjectIdGetDatum(deserialfn);
    values[Anum_pg_aggregate_aggmtransfn - 1] = ObjectIdGetDatum(mtransfn);
    values[Anum_pg_aggregate_aggminvtransfn - 1] = ObjectIdGetDatum(minvtransfn);
    values[Anum_pg_aggregate_aggmfinalfn - 1] = ObjectIdGetDatum(mfinalfn);
    values[Anum_pg_aggregate_aggfinalextra - 1] = BoolGetDatum(finalfnExtraArgs);
    values[Anum_pg_aggregate_aggmfinalextra - 1] = BoolGetDatum(mfinalfnExtraArgs);
    values[Anum_pg_aggregate_aggfinalmodify - 1] = CharGetDatum(finalfnModify);
    values[Anum_pg_aggregate_aggmfinalmodify - 1] = CharGetDatum(mfinalfnModify);
    values[Anum_pg_aggregate_aggsortop - 1] = ObjectIdGetDatum(sortop);
    values[Anum_pg_aggregate_aggtranstype - 1] = ObjectIdGetDatum(aggTransType);
    values[Anum_pg_aggregate_aggtransspace - 1] = Int32GetDatum(aggTransSpace);
    values[Anum_pg_aggregate_aggmtranstype - 1] = ObjectIdGetDatum(aggmTransType);
    values[Anum_pg_aggregate_aggmtransspace - 1] = Int32GetDatum(aggmTransSpace);
    if (agginitval)
        values[Anum_pg_aggregate_agginitval - 1] = CStringGetTextDatum(agginitval);
    else
        nulls[Anum_pg_aggregate_agginitval - 1] = true;
    if (aggminitval)
        values[Anum_pg_aggregate_aggminitval - 1] = CStringGetTextDatum(aggminitval);
    else
        nulls[Anum_pg_aggregate_aggminitval - 1] = true;
 
    if (replace)
        oldtup = SearchSysCache1(AGGFNOID, ObjectIdGetDatum(procOid));
    else
        oldtup = NULL;
 
    if (HeapTupleIsValid(oldtup))
    {
        Form_pg_aggregate oldagg = (Form_pg_aggregate) GETSTRUCT(oldtup);
 
        /*
         * If we're replacing an existing entry, we need to validate that
         * we're not changing anything that would break callers. Specifically
         * we must not change aggkind or aggnumdirectargs, which affect how an
         * aggregate call is treated in parse analysis.
         */
        if (aggKind != oldagg->aggkind)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("cannot change routine kind"),
                     (oldagg->aggkind == AGGKIND_NORMAL ?
                      errdetail("\"%s\" is an ordinary aggregate function.", aggName) :
                      oldagg->aggkind == AGGKIND_ORDERED_SET ?
                      errdetail("\"%s\" is an ordered-set aggregate.", aggName) :
                      oldagg->aggkind == AGGKIND_HYPOTHETICAL ?
                      errdetail("\"%s\" is a hypothetical-set aggregate.", aggName) :
                      0)));
        if (numDirectArgs != oldagg->aggnumdirectargs)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
                     errmsg("cannot change number of direct arguments of an aggregate function")));
 
        replaces[Anum_pg_aggregate_aggfnoid - 1] = false;
        replaces[Anum_pg_aggregate_aggkind - 1] = false;
        replaces[Anum_pg_aggregate_aggnumdirectargs - 1] = false;
 
        tup = heap_modify_tuple(oldtup, tupDesc, values, nulls, replaces);
        CatalogTupleUpdate(aggdesc, &tup->t_self, tup);
        ReleaseSysCache(oldtup);
    }
    else
    {
        tup = heap_form_tuple(tupDesc, values, nulls);
        CatalogTupleInsert(aggdesc, tup);
    }
 
    table_close(aggdesc, RowExclusiveLock);
 
    /*
     * Create dependencies for the aggregate (above and beyond those already
     * made by ProcedureCreate).  Note: we don't need an explicit dependency
     * on aggTransType since we depend on it indirectly through transfn.
     * Likewise for aggmTransType using the mtransfn, if it exists.
     *
     * If we're replacing an existing definition, ProcedureCreate deleted all
     * our existing dependencies, so we have to do the same things here either
     * way.
     */
 
    addrs = new_object_addresses();
 
    /* Depends on transition function */
    ObjectAddressSet(referenced, ProcedureRelationId, transfn);
    add_exact_object_address(&referenced, addrs);
 
    /* Depends on final function, if any */
    if (OidIsValid(finalfn))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, finalfn);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Depends on combine function, if any */
    if (OidIsValid(combinefn))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, combinefn);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Depends on serialization function, if any */
    if (OidIsValid(serialfn))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, serialfn);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Depends on deserialization function, if any */
    if (OidIsValid(deserialfn))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, deserialfn);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Depends on forward transition function, if any */
    if (OidIsValid(mtransfn))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, mtransfn);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Depends on inverse transition function, if any */
    if (OidIsValid(minvtransfn))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, minvtransfn);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Depends on final function, if any */
    if (OidIsValid(mfinalfn))
    {
        ObjectAddressSet(referenced, ProcedureRelationId, mfinalfn);
        add_exact_object_address(&referenced, addrs);
    }
 
    /* Depends on sort operator, if any */
    if (OidIsValid(sortop))
    {
        ObjectAddressSet(referenced, OperatorRelationId, sortop);
        add_exact_object_address(&referenced, addrs);
    }
 
    record_object_address_dependencies(&myself, addrs, DEPENDENCY_NORMAL);
    free_object_addresses(addrs);
    return myself;
}

References ACL_USAGE, aclcheck_error_type(), ACLCHECK_OK, add_exact_object_address(), Assert, BoolGetDatum(), CatalogTupleInsert(), CatalogTupleUpdate(), CharGetDatum(), check_valid_internal_signature(), check_valid_polymorphic_signature(), CStringGetTextDatum, DEPENDENCY_NORMAL, elog, ereport, errcode(), errdetail(), errdetail_internal(), errmsg, errmsg_plural(), ERROR, fb(), Form_pg_aggregate, Form_pg_proc, format_type_be(), free_object_addresses(), FUNC_MAX_ARGS, func_strict(), GETSTRUCT(), GetUserId(), heap_form_tuple(), heap_modify_tuple(), HeapTupleIsValid, i, Int16GetDatum(), Int32GetDatum(), InvalidOid, IsBinaryCoercible(), lookup_agg_function(), LookupOperName(), memcpy(), NameListToString(), new_object_addresses(), NIL, object_aclcheck(), ObjectAddressSet, ObjectIdGetDatum(), OidIsValid, PointerGetDatum, ProcedureCreate(), record_object_address_dependencies(), ReleaseSysCache(), RowExclusiveLock, SearchSysCache1(), table_close(), table_open(), oidvector::values, and values.

Referenced by DefineAggregate().

CATALOG()

BEGIN_CATALOG_STRUCT CATALOG	(	pg_aggregate	,
		2600	,
		AggregateRelationId
	)

Definition at line 34 of file pg_aggregate.h.

{
    /* pg_proc OID of the aggregate itself */
    regproc     aggfnoid BKI_LOOKUP(pg_proc);
 
    /* aggregate kind, see AGGKIND_ categories below */
    char        aggkind BKI_DEFAULT(n);
 
    /* number of arguments that are "direct" arguments */
    int16       aggnumdirectargs BKI_DEFAULT(0);
 
    /* transition function */
    regproc     aggtransfn BKI_LOOKUP(pg_proc);
 
    /* final function (0 if none) */
    regproc     aggfinalfn BKI_DEFAULT(-) BKI_LOOKUP_OPT(pg_proc);
 
    /* combine function (0 if none) */
    regproc     aggcombinefn BKI_DEFAULT(-) BKI_LOOKUP_OPT(pg_proc);
 
    /* function to convert transtype to bytea (0 if none) */
    regproc     aggserialfn BKI_DEFAULT(-) BKI_LOOKUP_OPT(pg_proc);
 
    /* function to convert bytea to transtype (0 if none) */
    regproc     aggdeserialfn BKI_DEFAULT(-) BKI_LOOKUP_OPT(pg_proc);
 
    /* forward function for moving-aggregate mode (0 if none) */
    regproc     aggmtransfn BKI_DEFAULT(-) BKI_LOOKUP_OPT(pg_proc);
 
    /* inverse function for moving-aggregate mode (0 if none) */
    regproc     aggminvtransfn BKI_DEFAULT(-) BKI_LOOKUP_OPT(pg_proc);
 
    /* final function for moving-aggregate mode (0 if none) */
    regproc     aggmfinalfn BKI_DEFAULT(-) BKI_LOOKUP_OPT(pg_proc);
 
    /* true to pass extra dummy arguments to aggfinalfn */
    bool        aggfinalextra BKI_DEFAULT(f);
 
    /* true to pass extra dummy arguments to aggmfinalfn */
    bool        aggmfinalextra BKI_DEFAULT(f);
 
    /* tells whether aggfinalfn modifies transition state */
    char        aggfinalmodify BKI_DEFAULT(r);
 
    /* tells whether aggmfinalfn modifies transition state */
    char        aggmfinalmodify BKI_DEFAULT(r);
 
    /* associated sort operator (0 if none) */
    Oid         aggsortop BKI_DEFAULT(0) BKI_LOOKUP_OPT(pg_operator);
 
    /* type of aggregate's transition (state) data */
    Oid         aggtranstype BKI_LOOKUP(pg_type);
 
    /* estimated size of state data (0 for default estimate) */
    int32       aggtransspace BKI_DEFAULT(0);
 
    /* type of moving-aggregate state data (0 if none) */
    Oid         aggmtranstype BKI_DEFAULT(0) BKI_LOOKUP_OPT(pg_type);
 
    /* estimated size of moving-agg state (0 for default est) */
    int32       aggmtransspace BKI_DEFAULT(0);
 
#ifdef CATALOG_VARLEN           /* variable-length fields start here */
 
    /* initial value for transition state (can be NULL) */
    text        agginitval BKI_DEFAULT(_null_);
 
    /* initial value for moving-agg state (can be NULL) */
    text        aggminitval BKI_DEFAULT(_null_);
#endif
} FormData_pg_aggregate;

References BKI_DEFAULT, BKI_LOOKUP, BKI_LOOKUP_OPT, and fb().

DECLARE_TOAST()

DECLARE_TOAST	(	pg_aggregate	,
		4159	,
		4160
	)

DECLARE_UNIQUE_INDEX_PKEY()

DECLARE_UNIQUE_INDEX_PKEY	(	pg_aggregate_fnoid_index	,
		2650	,
		AggregateFnoidIndexId	,
		pg_aggregate	,
		btree(aggfnoid oid_ops)
	)

MAKE_SYSCACHE()

MAKE_SYSCACHE	(	AGGFNOID	,
		pg_aggregate_fnoid_index	,
		16
	)

Variable Documentation

Form_pg_aggregate

END_CATALOG_STRUCT typedef FormData_pg_aggregate* Form_pg_aggregate

Definition at line 113 of file pg_aggregate.h.

Referenced by AggregateCreate(), ExecInitAgg(), fetch_agg_sort_op(), initialize_peragg(), ParseFuncOrColumn(), preprocess_aggref(), and print_function_arguments().

FormData_pg_aggregate

FormData_pg_aggregate

Definition at line 104 of file pg_aggregate.h.