/*-------------------------------------------------------------------------

 *

 * aggregatecmds.c

 *

 *    Routines for aggregate-manipulation commands

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 *

 * IDENTIFICATION

 *    src/backend/commands/aggregatecmds.c

 *

 * DESCRIPTION

 *    The "DefineAggregate" routine takes the parse tree and picks out the

 *    appropriate arguments/flags, passing the results to the

 *    "AggregateCreate" routine (in src/backend/catalog), which does the

 *    actual catalog-munging.  DefineAggregate also verifies the permission of

 *    the user to execute the command.

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "catalog/namespace.h"

#include "catalog/pg_aggregate.h"

#include "catalog/pg_namespace.h"

#include "catalog/pg_proc.h"

#include "catalog/pg_type.h"

#include "commands/defrem.h"

#include "miscadmin.h"

#include "parser/parse_type.h"

#include "utils/acl.h"

#include "utils/builtins.h"

#include "utils/lsyscache.h"

static char extractModify(DefElem *defel);

/*

 *  DefineAggregate

 *

 * "oldstyle" signals the old (pre-8.2) style where the aggregate input type

 * is specified by a BASETYPE element in the parameters.  Otherwise,

 * "args" is a pair, whose first element is a list of FunctionParameter structs

 * defining the agg's arguments (both direct and aggregated), and whose second

 * element is an Integer node with the number of direct args, or -1 if this

 * isn't an ordered-set aggregate.

 * "parameters" is a list of DefElem representing the agg's definition clauses.

 */

ObjectAddress

DefineAggregate(ParseState *pstate,

        List *name,

        List *args,

        bool oldstyle,

        List *parameters,

        bool replace)

{

  char     *aggName;

  Oid     aggNamespace;

  AclResult aclresult;

  char    aggKind = AGGKIND_NORMAL;

  List     *transfuncName = NIL;

  List     *finalfuncName = NIL;

  List     *combinefuncName = NIL;

  List     *serialfuncName = NIL;

  List     *deserialfuncName = NIL;

  List     *mtransfuncName = NIL;

  List     *minvtransfuncName = NIL;

  List     *mfinalfuncName = NIL;

  bool    finalfuncExtraArgs = false;

  bool    mfinalfuncExtraArgs = false;

  char    finalfuncModify = 0;

  char    mfinalfuncModify = 0;

  List     *sortoperatorName = NIL;

  List     *supportfuncName = NIL;

  TypeName   *baseType = NULL;

  TypeName   *transType = NULL;

  TypeName   *mtransType = NULL;

  int32   transSpace = 0;

  int32   mtransSpace = 0;

  char     *initval = NULL;

  char     *minitval = NULL;

  char     *parallel = NULL;

  int     numArgs;

  int     numDirectArgs = 0;

  oidvector  *parameterTypes;

  ArrayType  *allParameterTypes;

  ArrayType  *parameterModes;

  ArrayType  *parameterNames;

  List     *parameterDefaults;

  Oid     variadicArgType;

  Oid     transTypeId;

  Oid     mtransTypeId = InvalidOid;

  char    transTypeType;

  char    mtransTypeType = 0;

  char    proparallel = PROPARALLEL_UNSAFE;

  ListCell   *pl;

  /* Convert list of names to a name and namespace */

  aggNamespace = QualifiedNameGetCreationNamespace(name, &aggName);

  /* Check we have creation rights in target namespace */

  aclresult = object_aclcheck(NamespaceRelationId, aggNamespace, GetUserId(), ACL_CREATE);

  if (aclresult != ACLCHECK_OK)

    aclcheck_error(aclresult, OBJECT_SCHEMA,

             get_namespace_name(aggNamespace));

  /* Deconstruct the output of the aggr_args grammar production */

  if (!oldstyle)

  {

    Assert(list_length(args) == 2);

    numDirectArgs = intVal(lsecond(args));

    if (numDirectArgs >= 0)

      aggKind = AGGKIND_ORDERED_SET;

    else

      numDirectArgs = 0;

    args = linitial_node(List, args);

  }

  /* Examine aggregate's definition clauses */

  foreach(pl, parameters)

  {

    DefElem    *defel = lfirst_node(DefElem, pl);

    /*

     * sfunc1, stype1, and initcond1 are accepted as obsolete spellings

     * for sfunc, stype, initcond.

     */

    if (strcmp(defel->defname, "sfunc") == 0)

      transfuncName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "sfunc1") == 0)

      transfuncName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "finalfunc") == 0)

      finalfuncName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "combinefunc") == 0)

      combinefuncName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "serialfunc") == 0)

      serialfuncName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "deserialfunc") == 0)

      deserialfuncName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "msfunc") == 0)

      mtransfuncName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "minvfunc") == 0)

      minvtransfuncName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "mfinalfunc") == 0)

      mfinalfuncName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "finalfunc_extra") == 0)

      finalfuncExtraArgs = defGetBoolean(defel);

    else if (strcmp(defel->defname, "mfinalfunc_extra") == 0)

      mfinalfuncExtraArgs = defGetBoolean(defel);

    else if (strcmp(defel->defname, "finalfunc_modify") == 0)

      finalfuncModify = extractModify(defel);

    else if (strcmp(defel->defname, "mfinalfunc_modify") == 0)

      mfinalfuncModify = extractModify(defel);

    else if (strcmp(defel->defname, "sortop") == 0)

      sortoperatorName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "support") == 0)

      supportfuncName = defGetQualifiedName(defel);

    else if (strcmp(defel->defname, "basetype") == 0)

      baseType = defGetTypeName(defel);

    else if (strcmp(defel->defname, "hypothetical") == 0)

    {

      if (defGetBoolean(defel))

      {

        if (aggKind == AGGKIND_NORMAL)

          ereport(ERROR,

              (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

               errmsg("only ordered-set aggregates can be hypothetical")));

        aggKind = AGGKIND_HYPOTHETICAL;

      }

    }

    else if (strcmp(defel->defname, "stype") == 0)

      transType = defGetTypeName(defel);

    else if (strcmp(defel->defname, "stype1") == 0)

      transType = defGetTypeName(defel);

    else if (strcmp(defel->defname, "sspace") == 0)

      transSpace = defGetInt32(defel);

    else if (strcmp(defel->defname, "mstype") == 0)

      mtransType = defGetTypeName(defel);

    else if (strcmp(defel->defname, "msspace") == 0)

      mtransSpace = defGetInt32(defel);

    else if (strcmp(defel->defname, "initcond") == 0)

      initval = defGetString(defel);

    else if (strcmp(defel->defname, "initcond1") == 0)

      initval = defGetString(defel);

    else if (strcmp(defel->defname, "minitcond") == 0)

      minitval = defGetString(defel);

    else if (strcmp(defel->defname, "parallel") == 0)

      parallel = defGetString(defel);

    else

      ereport(WARNING,

          (errcode(ERRCODE_SYNTAX_ERROR),

           errmsg("aggregate attribute \"%s\" not recognized",

              defel->defname)));

  }

  /*

   * make sure we have our required definitions

   */

  if (transType == NULL)

    ereport(ERROR,

        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

         errmsg("aggregate stype must be specified")));

  if (transfuncName == NIL)

    ereport(ERROR,

        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

         errmsg("aggregate sfunc must be specified")));

  /*

   * if mtransType is given, mtransfuncName and minvtransfuncName must be as

   * well; if not, then none of the moving-aggregate options should have

   * been given.

   */

  if (mtransType != NULL)

  {

    if (mtransfuncName == NIL)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("aggregate msfunc must be specified when mstype is specified")));

    if (minvtransfuncName == NIL)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("aggregate minvfunc must be specified when mstype is specified")));

  }

  else

  {

    if (mtransfuncName != NIL)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("aggregate msfunc must not be specified without mstype")));

    if (minvtransfuncName != NIL)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("aggregate minvfunc must not be specified without mstype")));

    if (mfinalfuncName != NIL)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("aggregate mfinalfunc must not be specified without mstype")));

    if (mtransSpace != 0)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("aggregate msspace must not be specified without mstype")));

    if (minitval != NULL)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("aggregate minitcond must not be specified without mstype")));

  }

  /*

   * Default values for modify flags can only be determined once we know the

   * aggKind.

   */

  if (finalfuncModify == 0)

    finalfuncModify = (aggKind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;

  if (mfinalfuncModify == 0)

    mfinalfuncModify = (aggKind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;

  /*

   * look up the aggregate's input datatype(s).

   */

  if (oldstyle)

  {

    /*

     * Old style: use basetype parameter.  This supports aggregates of

     * zero or one input, with input type ANY meaning zero inputs.

     *

     * Historically we allowed the command to look like basetype = 'ANY'

     * so we must do a case-insensitive comparison for the name ANY. Ugh.

     */

    Oid     aggArgTypes[1];

    if (baseType == NULL)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("aggregate input type must be specified")));

    if (pg_strcasecmp(TypeNameToString(baseType), "ANY") == 0)

    {

      numArgs = 0;

      aggArgTypes[0] = InvalidOid;

    }

    else

    {

      numArgs = 1;

      aggArgTypes[0] = typenameTypeId(NULL, baseType);

    }

    parameterTypes = buildoidvector(aggArgTypes, numArgs);

    allParameterTypes = NULL;

    parameterModes = NULL;

    parameterNames = NULL;

    parameterDefaults = NIL;

    variadicArgType = InvalidOid;

  }

  else

  {

    /*

     * New style: args is a list of FunctionParameters (possibly zero of

     * 'em).  We share functioncmds.c's code for processing them.

     */

    Oid     requiredResultType;

    if (baseType != NULL)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("basetype is redundant with aggregate input type specification")));

    numArgs = list_length(args);

    interpret_function_parameter_list(pstate,

                      args,

                      InvalidOid,

                      OBJECT_AGGREGATE,

                      &parameterTypes,

                      NULL,

                      &allParameterTypes,

                      &parameterModes,

                      &parameterNames,

                      NULL,

                      &parameterDefaults,

                      &variadicArgType,

                      &requiredResultType);

    /* Parameter defaults are not currently allowed by the grammar */

    Assert(parameterDefaults == NIL);

    /* There shouldn't have been any OUT parameters, either */

    Assert(requiredResultType == InvalidOid);

  }

  /*

   * look up the aggregate's transtype.

   *

   * transtype can't be a pseudo-type, since we need to be able to store

   * values of the transtype.  However, we can allow polymorphic transtype

   * in some cases (AggregateCreate will check).  Also, we allow "internal"

   * for functions that want to pass pointers to private data structures;

   * but allow that only to superusers, since you could crash the system (or

   * worse) by connecting up incompatible internal-using functions in an

   * aggregate.

   */

  transTypeId = typenameTypeId(NULL, transType);

  transTypeType = get_typtype(transTypeId);

  if (transTypeType == TYPTYPE_PSEUDO &&

    !IsPolymorphicType(transTypeId))

  {

    if (transTypeId == INTERNALOID && superuser())

       /* okay */ ;

    else

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("aggregate transition data type cannot be %s",

              format_type_be(transTypeId))));

  }

  if (serialfuncName && deserialfuncName)

  {

    /*

     * Serialization is only needed/allowed for transtype INTERNAL.

     */

    if (transTypeId != INTERNALOID)

      ereport(ERROR,

          (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

           errmsg("serialization functions may be specified only when the aggregate transition data type is %s",

              format_type_be(INTERNALOID))));

  }

  else if (serialfuncName || deserialfuncName)

  {

    /*

     * Cannot specify one function without the other.

     */

    ereport(ERROR,

        (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

         errmsg("must specify both or neither of serialization and deserialization functions")));

  }

  /*

   * If a moving-aggregate transtype is specified, look that up.  Same

   * restrictions as for transtype.

   */

  if (mtransType)

  {

    mtransTypeId = typenameTypeId(NULL, mtransType);

    mtransTypeType = get_typtype(mtransTypeId);

    if (mtransTypeType == TYPTYPE_PSEUDO &&

      !IsPolymorphicType(mtransTypeId))

    {

      if (mtransTypeId == INTERNALOID && superuser())

         /* okay */ ;

      else

        ereport(ERROR,

            (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

             errmsg("aggregate transition data type cannot be %s",

                format_type_be(mtransTypeId))));

    }

  }

  /*

   * If we have an initval, and it's not for a pseudotype (particularly a

   * polymorphic type), make sure it's acceptable to the type's input

   * function.  We will store the initval as text, because the input

   * function isn't necessarily immutable (consider "now" for timestamp),

   * and we want to use the runtime not creation-time interpretation of the

   * value.  However, if it's an incorrect value it seems much more

   * user-friendly to complain at CREATE AGGREGATE time.

   */

  if (initval && transTypeType != TYPTYPE_PSEUDO)

  {

    Oid     typinput,

          typioparam;

    getTypeInputInfo(transTypeId, &typinput, &typioparam);

    (void) OidInputFunctionCall(typinput, initval, typioparam, -1);

  }

  /*

   * Likewise for moving-aggregate initval.

   */

  if (minitval && mtransTypeType != TYPTYPE_PSEUDO)

  {

    Oid     typinput,

          typioparam;

    getTypeInputInfo(mtransTypeId, &typinput, &typioparam);

    (void) OidInputFunctionCall(typinput, minitval, typioparam, -1);

  }

  if (parallel)

  {

    if (strcmp(parallel, "safe") == 0)

      proparallel = PROPARALLEL_SAFE;

    else if (strcmp(parallel, "restricted") == 0)

      proparallel = PROPARALLEL_RESTRICTED;

    else if (strcmp(parallel, "unsafe") == 0)

      proparallel = PROPARALLEL_UNSAFE;

    else

      ereport(ERROR,

          (errcode(ERRCODE_SYNTAX_ERROR),

           errmsg("parameter \"parallel\" must be SAFE, RESTRICTED, or UNSAFE")));

  }

  /*

   * Most of the argument-checking is done inside of AggregateCreate

   */

  return AggregateCreate(aggName, /* aggregate name */

               aggNamespace,  /* namespace */

               replace,

               aggKind,

               numArgs,

               numDirectArgs,

               parameterTypes,

               PointerGetDatum(allParameterTypes),

               PointerGetDatum(parameterModes),

               PointerGetDatum(parameterNames),

               parameterDefaults,

               variadicArgType,

               transfuncName, /* step function name */

               finalfuncName, /* final function name */

               combinefuncName, /* combine function name */

               serialfuncName,  /* serial function name */

               deserialfuncName,  /* deserial function name */

               mtransfuncName,  /* fwd trans function name */

               minvtransfuncName, /* inv trans function name */

               mfinalfuncName,  /* final function name */

               finalfuncExtraArgs,

               mfinalfuncExtraArgs,

               finalfuncModify,

               mfinalfuncModify,

               sortoperatorName,  /* sort operator name */

               supportfuncName, /* planner support func name */

               transTypeId, /* transition data type */

               transSpace,  /* transition space */

               mtransTypeId,  /* transition data type */

               mtransSpace, /* transition space */

               initval, /* initial condition */

               minitval,  /* initial condition */

               proparallel);  /* parallel safe? */

}

/*

 * Convert the string form of [m]finalfunc_modify to the catalog representation

 */

static char

extractModify(DefElem *defel)

{

  char     *val = defGetString(defel);

  if (strcmp(val, "read_only") == 0)

    return AGGMODIFY_READ_ONLY;

  if (strcmp(val, "shareable") == 0)

    return AGGMODIFY_SHAREABLE;

  if (strcmp(val, "read_write") == 0)

    return AGGMODIFY_READ_WRITE;

  ereport(ERROR,

      (errcode(ERRCODE_SYNTAX_ERROR),

       errmsg("parameter \"%s\" must be READ_ONLY, SHAREABLE, or READ_WRITE",

          defel->defname)));

  return 0;         /* keep compiler quiet */

}