/*-------------------------------------------------------------------------
 *
 * aggregatecmds.c
 *
 *   Routines for aggregate-manipulation commands
 *
 * Portions Copyright (c) 1996-2025, 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;
 TypeName   *baseType = NULL;
 TypeName   *transType = NULL;
 TypeName   *mtransType = NULL;
 int32  transSpace = 0;
 int32  mtransSpace = 0;
 char    *initval = NULL;
 char    *minitval = NULL;
 char    *parallel = NULL;
 int   numArgs;
 int   numDirectArgs = 0;
 oidvector  *parameterTypes;
 ArrayType  *allParameterTypes;
 ArrayType  *parameterModes;
 ArrayType  *parameterNames;
 List    *parameterDefaults;
 Oid   variadicArgType;
 Oid   transTypeId;
 Oid   mtransTypeId = InvalidOid;
 char  transTypeType;
 char  mtransTypeType = 0;
 char  proparallel = PROPARALLEL_UNSAFE;
 ListCell   *pl;

 /* Convert list of names to a name and namespace */
 aggNamespace = QualifiedNameGetCreationNamespace(name, &aggName);

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

 /* Deconstruct the output of the aggr_args grammar production */
 if (!oldstyle)
 {
  Assert(list_length(args) == 2);
  numDirectArgs = intVal(lsecond(args));
  if (numDirectArgs >= 0)
   aggKind = AGGKIND_ORDERED_SET;
  else
   numDirectArgs = 0;
  args = linitial_node(List, args);
 }

 /* Examine aggregate's definition clauses */
 foreach(pl, parameters)
 {
  DefElem    *defel = lfirst_node(DefElem, pl);

  /*
   * sfunc1, stype1, and initcond1 are accepted as obsolete spellings
   * for sfunc, stype, initcond.
 */
  if (strcmp(defel->defname, "sfunc") == 0)
   transfuncName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "sfunc1") == 0)
   transfuncName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "finalfunc") == 0)
   finalfuncName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "combinefunc") == 0)
   combinefuncName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "serialfunc") == 0)
   serialfuncName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "deserialfunc") == 0)
   deserialfuncName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "msfunc") == 0)
   mtransfuncName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "minvfunc") == 0)
   minvtransfuncName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "mfinalfunc") == 0)
   mfinalfuncName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "finalfunc_extra") == 0)
   finalfuncExtraArgs = defGetBoolean(defel);
  else if (strcmp(defel->defname, "mfinalfunc_extra") == 0)
   mfinalfuncExtraArgs = defGetBoolean(defel);
  else if (strcmp(defel->defname, "finalfunc_modify") == 0)
   finalfuncModify = extractModify(defel);
  else if (strcmp(defel->defname, "mfinalfunc_modify") == 0)
   mfinalfuncModify = extractModify(defel);
  else if (strcmp(defel->defname, "sortop") == 0)
   sortoperatorName = defGetQualifiedName(defel);
  else if (strcmp(defel->defname, "basetype") == 0)
   baseType = defGetTypeName(defel);
  else if (strcmp(defel->defname, "hypothetical") == 0)
  {
   if (defGetBoolean(defel))
   {
    if (aggKind == AGGKIND_NORMAL)
     ereport(ERROR,
       (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
        errmsg("only ordered-set aggregates can be hypothetical")));
    aggKind = AGGKIND_HYPOTHETICAL;
   }
  }
  else if (strcmp(defel->defname, "stype") == 0)
   transType = defGetTypeName(defel);
  else if (strcmp(defel->defname, "stype1") == 0)
   transType = defGetTypeName(defel);
  else if (strcmp(defel->defname, "sspace") == 0)
   transSpace = defGetInt32(defel);
  else if (strcmp(defel->defname, "mstype") == 0)
   mtransType = defGetTypeName(defel);
  else if (strcmp(defel->defname, "msspace") == 0)
   mtransSpace = defGetInt32(defel);
  else if (strcmp(defel->defname, "initcond") == 0)
   initval = defGetString(defel);
  else if (strcmp(defel->defname, "initcond1") == 0)
   initval = defGetString(defel);
  else if (strcmp(defel->defname, "minitcond") == 0)
   minitval = defGetString(defel);
  else if (strcmp(defel->defname, "parallel") == 0)
   parallel = defGetString(defel);
  else
   ereport(WARNING,
     (errcode(ERRCODE_SYNTAX_ERROR),
      errmsg("aggregate attribute \"%s\" not recognized",
       defel->defname)));
 }

 /*
  * make sure we have our required definitions
 */
 if (transType == NULL)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("aggregate stype must be specified")));
 if (transfuncName == NIL)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("aggregate sfunc must be specified")));

 /*
  * if mtransType is given, mtransfuncName and minvtransfuncName must be as
  * well; if not, then none of the moving-aggregate options should have
  * been given.
 */
 if (mtransType != NULL)
 {
  if (mtransfuncName == NIL)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("aggregate msfunc must be specified when mstype is specified")));
  if (minvtransfuncName == NIL)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("aggregate minvfunc must be specified when mstype is specified")));
 }
 else
 {
  if (mtransfuncName != NIL)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("aggregate msfunc must not be specified without mstype")));
  if (minvtransfuncName != NIL)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("aggregate minvfunc must not be specified without mstype")));
  if (mfinalfuncName != NIL)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("aggregate mfinalfunc must not be specified without mstype")));
  if (mtransSpace != 0)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("aggregate msspace must not be specified without mstype")));
  if (minitval != NULL)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("aggregate minitcond must not be specified without mstype")));
 }

 /*
  * Default values for modify flags can only be determined once we know the
  * aggKind.
 */
 if (finalfuncModify == 0)
  finalfuncModify = (aggKind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
 if (mfinalfuncModify == 0)
  mfinalfuncModify = (aggKind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;

 /*
  * look up the aggregate's input datatype(s).
 */
 if (oldstyle)
 {
  /*
   * Old style: use basetype parameter.  This supports aggregates of
   * zero or one input, with input type ANY meaning zero inputs.
   *
   * Historically we allowed the command to look like basetype = 'ANY'
   * so we must do a case-insensitive comparison for the name ANY. Ugh.
 */
  Oid   aggArgTypes[1];

  if (baseType == NULL)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("aggregate input type must be specified")));

  if (pg_strcasecmp(TypeNameToString(baseType), "ANY") == 0)
  {
   numArgs = 0;
   aggArgTypes[0] = InvalidOid;
  }
  else
  {
   numArgs = 1;
   aggArgTypes[0] = typenameTypeId(NULL, baseType);
  }
  parameterTypes = buildoidvector(aggArgTypes, numArgs);
  allParameterTypes = NULL;
  parameterModes = NULL;
  parameterNames = NULL;
  parameterDefaults = NIL;
  variadicArgType = InvalidOid;
 }
 else
 {
  /*
   * New style: args is a list of FunctionParameters (possibly zero of
   * 'em).  We share functioncmds.c's code for processing them.
 */
  Oid   requiredResultType;

  if (baseType != NULL)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("basetype is redundant with aggregate input type specification")));

  numArgs = list_length(args);
  interpret_function_parameter_list(pstate,
            args,
            InvalidOid,
            OBJECT_AGGREGATE,
            ¶meterTypes,
            NULL,
            &allParameterTypes,
            ¶meterModes,
            ¶meterNames,
            NULL,
            ¶meterDefaults,
            &variadicArgType,
            &requiredResultType);
  /* Parameter defaults are not currently allowed by the grammar */
  Assert(parameterDefaults == NIL);
  /* There shouldn't have been any OUT parameters, either */
  Assert(requiredResultType == InvalidOid);
 }

 /*
  * look up the aggregate's transtype.
  *
  * transtype can't be a pseudo-type, since we need to be able to store
  * values of the transtype.  However, we can allow polymorphic transtype
  * in some cases (AggregateCreate will check).  Also, we allow "internal"
  * for functions that want to pass pointers to private data structures;
  * but allow that only to superusers, since you could crash the system (or
  * worse) by connecting up incompatible internal-using functions in an
  * aggregate.
 */
 transTypeId = typenameTypeId(NULL, transType);
 transTypeType = get_typtype(transTypeId);
 if (transTypeType == TYPTYPE_PSEUDO &&
  !IsPolymorphicType(transTypeId))
 {
  if (transTypeId == INTERNALOID && superuser())
    /* okay */ ;
  else
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("aggregate transition data type cannot be %s",
       format_type_be(transTypeId))));
 }

 if (serialfuncName && deserialfuncName)
 {
  /*
   * Serialization is only needed/allowed for transtype INTERNAL.
 */
  if (transTypeId != INTERNALOID)
   ereport(ERROR,
     (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
      errmsg("serialization functions may be specified only when the aggregate transition data type is %s",
       format_type_be(INTERNALOID))));
 }
 else if (serialfuncName || deserialfuncName)
 {
  /*
   * Cannot specify one function without the other.
 */
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
     errmsg("must specify both or neither of serialization and deserialization functions")));
 }

 /*
  * If a moving-aggregate transtype is specified, look that up.  Same
  * restrictions as for transtype.
 */
 if (mtransType)
 {
  mtransTypeId = typenameTypeId(NULL, mtransType);
  mtransTypeType = get_typtype(mtransTypeId);
  if (mtransTypeType == TYPTYPE_PSEUDO &&
   !IsPolymorphicType(mtransTypeId))
  {
   if (mtransTypeId == INTERNALOID && superuser())
     /* okay */ ;
   else
    ereport(ERROR,
      (errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
       errmsg("aggregate transition data type cannot be %s",
        format_type_be(mtransTypeId))));
  }
 }

 /*
  * If we have an initval, and it's not for a pseudotype (particularly a
  * polymorphic type), make sure it's acceptable to the type's input
  * function.  We will store the initval as text, because the input
  * function isn't necessarily immutable (consider "now" for timestamp),
  * and we want to use the runtime not creation-time interpretation of the
  * value.  However, if it's an incorrect value it seems much more
  * user-friendly to complain at CREATE AGGREGATE time.
 */
 if (initval && transTypeType != TYPTYPE_PSEUDO)
 {
  Oid   typinput,
     typioparam;

  getTypeInputInfo(transTypeId, &typinput, &typioparam);
  (void) OidInputFunctionCall(typinput, initval, typioparam, -1);
 }

 /*
  * Likewise for moving-aggregate initval.
 */
 if (minitval && mtransTypeType != TYPTYPE_PSEUDO)
 {
  Oid   typinput,
     typioparam;

  getTypeInputInfo(mtransTypeId, &typinput, &typioparam);
  (void) OidInputFunctionCall(typinput, minitval, typioparam, -1);
 }

 if (parallel)
 {
  if (strcmp(parallel, "safe") == 0)
   proparallel = PROPARALLEL_SAFE;
  else if (strcmp(parallel, "restricted") == 0)
   proparallel = PROPARALLEL_RESTRICTED;
  else if (strcmp(parallel, "unsafe") == 0)
   proparallel = PROPARALLEL_UNSAFE;
  else
   ereport(ERROR,
     (errcode(ERRCODE_SYNTAX_ERROR),
      errmsg("parameter \"parallel\" must be SAFE, RESTRICTED, or UNSAFE")));
 }

 /*
  * Most of the argument-checking is done inside of AggregateCreate
 */
 return AggregateCreate(aggName, /* aggregate name */
         aggNamespace, /* namespace */
         replace,
         aggKind,
         numArgs,
         numDirectArgs,
         parameterTypes,
         PointerGetDatum(allParameterTypes),
         PointerGetDatum(parameterModes),
         PointerGetDatum(parameterNames),
         parameterDefaults,
         variadicArgType,
         transfuncName, /* step function name */
         finalfuncName, /* final function name */
         combinefuncName, /* combine function name */
         serialfuncName, /* serial function name */
         deserialfuncName, /* deserial function name */
         mtransfuncName, /* fwd trans function name */
         minvtransfuncName, /* inv trans function name */
         mfinalfuncName, /* final function name */
         finalfuncExtraArgs,
         mfinalfuncExtraArgs,
         finalfuncModify,
         mfinalfuncModify,
         sortoperatorName, /* sort operator name */
         transTypeId, /* transition data type */
         transSpace, /* transition space */
         mtransTypeId, /* transition data type */
         mtransSpace, /* transition space */
         initval, /* initial condition */
         minitval, /* initial condition */
         proparallel); /* parallel safe? */
}

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