parse_agg.h File Reference

#include "parser/parse_node.h"

Include dependency graph for parse_agg.h:

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

Go to the source code of this file.

Functions
void	transformAggregateCall (ParseState *pstate, Aggref *agg, List *args, List *aggorder, bool agg_distinct)
Node *	transformGroupingFunc (ParseState *pstate, GroupingFunc *p)
void	transformWindowFuncCall (ParseState *pstate, WindowFunc *wfunc, WindowDef *windef)
void	parseCheckAggregates (ParseState *pstate, Query *qry)
List *	expand_grouping_sets (List *groupingSets, bool groupDistinct, int limit)
int	get_aggregate_argtypes (Aggref *aggref, Oid *inputTypes)
Oid	resolve_aggregate_transtype (Oid aggfuncid, Oid aggtranstype, Oid *inputTypes, int numArguments)
bool	agg_args_support_sendreceive (Aggref *aggref)
void	build_aggregate_transfn_expr (Oid *agg_input_types, int agg_num_inputs, int agg_num_direct_inputs, bool agg_variadic, Oid agg_state_type, Oid agg_input_collation, Oid transfn_oid, Oid invtransfn_oid, Expr **transfnexpr, Expr **invtransfnexpr)
void	build_aggregate_serialfn_expr (Oid serialfn_oid, Expr **serialfnexpr)
void	build_aggregate_deserialfn_expr (Oid deserialfn_oid, Expr **deserialfnexpr)
void	build_aggregate_finalfn_expr (Oid *agg_input_types, int num_finalfn_inputs, Oid agg_state_type, Oid agg_result_type, Oid agg_input_collation, Oid finalfn_oid, Expr **finalfnexpr)

Function Documentation

agg_args_support_sendreceive()

bool agg_args_support_sendreceive

(

Aggref *

aggref

)

Definition at line 2059 of file parse_agg.c.

{
    ListCell   *lc;
 
    foreach(lc, aggref->args)
    {
        HeapTuple   typeTuple;
        Form_pg_type pt;
        TargetEntry *tle = (TargetEntry *) lfirst(lc);
        Oid         type = exprType((Node *) tle->expr);
 
        /*
         * RECORD is a special case: it has typsend/typreceive functions, but
         * record_recv only works if passed the correct typmod to identify the
         * specific anonymous record type.  array_agg_deserialize cannot do
         * that, so we have to disclaim support for the case.
         */
        if (type == RECORDOID)
            return false;
 
        typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
        if (!HeapTupleIsValid(typeTuple))
            elog(ERROR, "cache lookup failed for type %u", type);
 
        pt = (Form_pg_type) GETSTRUCT(typeTuple);
 
        if (!pt->typbyval &&
            (!OidIsValid(pt->typsend) || !OidIsValid(pt->typreceive)))
        {
            ReleaseSysCache(typeTuple);
            return false;
        }
        ReleaseSysCache(typeTuple);
    }
    return true;
}

References Aggref::args, elog, ERROR, TargetEntry::expr, exprType(), GETSTRUCT(), HeapTupleIsValid, lfirst, ObjectIdGetDatum(), OidIsValid, ReleaseSysCache(), SearchSysCache1(), and type.

Referenced by preprocess_aggref().

build_aggregate_deserialfn_expr()

void build_aggregate_deserialfn_expr	(	Oid	deserialfn_oid,
		Expr **	deserialfnexpr
	)

Definition at line 2210 of file parse_agg.c.

{
    List       *args;
    FuncExpr   *fexpr;
 
    /* deserialfn always takes BYTEA, INTERNAL and returns INTERNAL */
    args = list_make2(make_agg_arg(BYTEAOID, InvalidOid),
                      make_agg_arg(INTERNALOID, InvalidOid));
 
    fexpr = makeFuncExpr(deserialfn_oid,
                         INTERNALOID,
                         args,
                         InvalidOid,
                         InvalidOid,
                         COERCE_EXPLICIT_CALL);
    *deserialfnexpr = (Expr *) fexpr;
}

References generate_unaccent_rules::args, COERCE_EXPLICIT_CALL, InvalidOid, list_make2, make_agg_arg(), and makeFuncExpr().

Referenced by build_pertrans_for_aggref().

build_aggregate_finalfn_expr()

void build_aggregate_finalfn_expr	(	Oid *	agg_input_types,
		int	num_finalfn_inputs,
		Oid	agg_state_type,
		Oid	agg_result_type,
		Oid	agg_input_collation,
		Oid	finalfn_oid,
		Expr **	finalfnexpr
	)

Definition at line 2234 of file parse_agg.c.

{
    List       *args;
    int         i;
 
    /*
     * Build expr tree for final function
     */
    args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
 
    /* finalfn may take additional args, which match agg's input types */
    for (i = 0; i < num_finalfn_inputs - 1; i++)
    {
        args = lappend(args,
                       make_agg_arg(agg_input_types[i], agg_input_collation));
    }
 
    *finalfnexpr = (Expr *) makeFuncExpr(finalfn_oid,
                                         agg_result_type,
                                         args,
                                         InvalidOid,
                                         agg_input_collation,
                                         COERCE_EXPLICIT_CALL);
    /* finalfn is currently never treated as variadic */
}

References generate_unaccent_rules::args, COERCE_EXPLICIT_CALL, i, InvalidOid, lappend(), list_make1, make_agg_arg(), and makeFuncExpr().

Referenced by ExecInitAgg(), and initialize_peragg().

build_aggregate_serialfn_expr()

void build_aggregate_serialfn_expr	(	Oid	serialfn_oid,
		Expr **	serialfnexpr
	)

Definition at line 2187 of file parse_agg.c.

{
    List       *args;
    FuncExpr   *fexpr;
 
    /* serialfn always takes INTERNAL and returns BYTEA */
    args = list_make1(make_agg_arg(INTERNALOID, InvalidOid));
 
    fexpr = makeFuncExpr(serialfn_oid,
                         BYTEAOID,
                         args,
                         InvalidOid,
                         InvalidOid,
                         COERCE_EXPLICIT_CALL);
    *serialfnexpr = (Expr *) fexpr;
}

References generate_unaccent_rules::args, COERCE_EXPLICIT_CALL, InvalidOid, list_make1, make_agg_arg(), and makeFuncExpr().

Referenced by build_pertrans_for_aggref().

build_aggregate_transfn_expr()

void build_aggregate_transfn_expr	(	Oid *	agg_input_types,
		int	agg_num_inputs,
		int	agg_num_direct_inputs,
		bool	agg_variadic,
		Oid	agg_state_type,
		Oid	agg_input_collation,
		Oid	transfn_oid,
		Oid	invtransfn_oid,
		Expr **	transfnexpr,
		Expr **	invtransfnexpr
	)

Definition at line 2126 of file parse_agg.c.

{
    List       *args;
    FuncExpr   *fexpr;
    int         i;
 
    /*
     * Build arg list to use in the transfn FuncExpr node.
     */
    args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
 
    for (i = agg_num_direct_inputs; i < agg_num_inputs; i++)
    {
        args = lappend(args,
                       make_agg_arg(agg_input_types[i], agg_input_collation));
    }
 
    fexpr = makeFuncExpr(transfn_oid,
                         agg_state_type,
                         args,
                         InvalidOid,
                         agg_input_collation,
                         COERCE_EXPLICIT_CALL);
    fexpr->funcvariadic = agg_variadic;
    *transfnexpr = (Expr *) fexpr;
 
    /*
     * Build invtransfn expression if requested, with same args as transfn
     */
    if (invtransfnexpr != NULL)
    {
        if (OidIsValid(invtransfn_oid))
        {
            fexpr = makeFuncExpr(invtransfn_oid,
                                 agg_state_type,
                                 args,
                                 InvalidOid,
                                 agg_input_collation,
                                 COERCE_EXPLICIT_CALL);
            fexpr->funcvariadic = agg_variadic;
            *invtransfnexpr = (Expr *) fexpr;
        }
        else
            *invtransfnexpr = NULL;
    }
}

References generate_unaccent_rules::args, COERCE_EXPLICIT_CALL, i, InvalidOid, lappend(), list_make1, make_agg_arg(), makeFuncExpr(), and OidIsValid.

Referenced by build_pertrans_for_aggref(), and initialize_peragg().

expand_grouping_sets()

List * expand_grouping_sets	(	List *	groupingSets,
		bool	groupDistinct,
		int	limit
	)

Definition at line 1894 of file parse_agg.c.

{
    List       *expanded_groups = NIL;
    List       *result = NIL;
    double      numsets = 1;
    ListCell   *lc;
 
    if (groupingSets == NIL)
        return NIL;
 
    foreach(lc, groupingSets)
    {
        List       *current_result = NIL;
        GroupingSet *gs = lfirst(lc);
 
        current_result = expand_groupingset_node(gs);
 
        Assert(current_result != NIL);
 
        numsets *= list_length(current_result);
 
        if (limit >= 0 && numsets > limit)
            return NIL;
 
        expanded_groups = lappend(expanded_groups, current_result);
    }
 
    /*
     * Do cartesian product between sublists of expanded_groups. While at it,
     * remove any duplicate elements from individual grouping sets (we must
     * NOT change the number of sets though)
     */
 
    foreach(lc, (List *) linitial(expanded_groups))
    {
        result = lappend(result, list_union_int(NIL, (List *) lfirst(lc)));
    }
 
    for_each_from(lc, expanded_groups, 1)
    {
        List       *p = lfirst(lc);
        List       *new_result = NIL;
        ListCell   *lc2;
 
        foreach(lc2, result)
        {
            List       *q = lfirst(lc2);
            ListCell   *lc3;
 
            foreach(lc3, p)
            {
                new_result = lappend(new_result,
                                     list_union_int(q, (List *) lfirst(lc3)));
            }
        }
        result = new_result;
    }
 
    /* Now sort the lists by length and deduplicate if necessary */
    if (!groupDistinct || list_length(result) < 2)
        list_sort(result, cmp_list_len_asc);
    else
    {
        ListCell   *cell;
        List       *prev;
 
        /* Sort each groupset individually */
        foreach(cell, result)
            list_sort(lfirst(cell), list_int_cmp);
 
        /* Now sort the list of groupsets by length and contents */
        list_sort(result, cmp_list_len_contents_asc);
 
        /* Finally, remove duplicates */
        prev = linitial(result);
        for_each_from(cell, result, 1)
        {
            if (equal(lfirst(cell), prev))
                result = foreach_delete_current(result, cell);
            else
                prev = lfirst(cell);
        }
    }
 
    return result;
}

References Assert(), cmp_list_len_asc(), cmp_list_len_contents_asc(), equal(), expand_groupingset_node(), for_each_from, foreach_delete_current, lappend(), lfirst, linitial, list_int_cmp(), list_length(), list_sort(), list_union_int(), and NIL.

Referenced by parseCheckAggregates(), and preprocess_grouping_sets().

get_aggregate_argtypes()

int get_aggregate_argtypes	(	Aggref *	aggref,
		Oid *	inputTypes
	)

Definition at line 1997 of file parse_agg.c.

{
    int         numArguments = 0;
    ListCell   *lc;
 
    Assert(list_length(aggref->aggargtypes) <= FUNC_MAX_ARGS);
 
    foreach(lc, aggref->aggargtypes)
    {
        inputTypes[numArguments++] = lfirst_oid(lc);
    }
 
    return numArguments;
}

References Assert(), FUNC_MAX_ARGS, lfirst_oid, and list_length().

Referenced by ExecInitAgg(), get_agg_expr_helper(), and preprocess_aggref().

parseCheckAggregates()

void parseCheckAggregates	(	ParseState *	pstate,
		Query *	qry
	)

Definition at line 1085 of file parse_agg.c.

{
    List       *gset_common = NIL;
    List       *groupClauses = NIL;
    List       *groupClauseCommonVars = NIL;
    bool        have_non_var_grouping;
    List       *func_grouped_rels = NIL;
    ListCell   *l;
    bool        hasJoinRTEs;
    bool        hasSelfRefRTEs;
    Node       *clause;
 
    /* This should only be called if we found aggregates or grouping */
    Assert(pstate->p_hasAggs || qry->groupClause || qry->havingQual || qry->groupingSets);
 
    /*
     * If we have grouping sets, expand them and find the intersection of all
     * sets.
     */
    if (qry->groupingSets)
    {
        /*
         * The limit of 4096 is arbitrary and exists simply to avoid resource
         * issues from pathological constructs.
         */
        List       *gsets = expand_grouping_sets(qry->groupingSets, qry->groupDistinct, 4096);
 
        if (!gsets)
            ereport(ERROR,
                    (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
                     errmsg("too many grouping sets present (maximum 4096)"),
                     parser_errposition(pstate,
                                        qry->groupClause
                                        ? exprLocation((Node *) qry->groupClause)
                                        : exprLocation((Node *) qry->groupingSets))));
 
        /*
         * The intersection will often be empty, so help things along by
         * seeding the intersect with the smallest set.
         */
        gset_common = linitial(gsets);
 
        if (gset_common)
        {
            for_each_from(l, gsets, 1)
            {
                gset_common = list_intersection_int(gset_common, lfirst(l));
                if (!gset_common)
                    break;
            }
        }
 
        /*
         * If there was only one grouping set in the expansion, AND if the
         * groupClause is non-empty (meaning that the grouping set is not
         * empty either), then we can ditch the grouping set and pretend we
         * just had a normal GROUP BY.
         */
        if (list_length(gsets) == 1 && qry->groupClause)
            qry->groupingSets = NIL;
    }
 
    /*
     * Scan the range table to see if there are JOIN or self-reference CTE
     * entries.  We'll need this info below.
     */
    hasJoinRTEs = hasSelfRefRTEs = false;
    foreach(l, pstate->p_rtable)
    {
        RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
 
        if (rte->rtekind == RTE_JOIN)
            hasJoinRTEs = true;
        else if (rte->rtekind == RTE_CTE && rte->self_reference)
            hasSelfRefRTEs = true;
    }
 
    /*
     * Build a list of the acceptable GROUP BY expressions for use by
     * substitute_grouped_columns().
     *
     * We get the TLE, not just the expr, because GROUPING wants to know the
     * sortgroupref.
     */
    foreach(l, qry->groupClause)
    {
        SortGroupClause *grpcl = (SortGroupClause *) lfirst(l);
        TargetEntry *expr;
 
        expr = get_sortgroupclause_tle(grpcl, qry->targetList);
        if (expr == NULL)
            continue;           /* probably cannot happen */
 
        groupClauses = lappend(groupClauses, expr);
    }
 
    /*
     * If there are join alias vars involved, we have to flatten them to the
     * underlying vars, so that aliased and unaliased vars will be correctly
     * taken as equal.  We can skip the expense of doing this if no rangetable
     * entries are RTE_JOIN kind.
     */
    if (hasJoinRTEs)
        groupClauses = (List *) flatten_join_alias_vars(NULL, qry,
                                                        (Node *) groupClauses);
 
    /*
     * Detect whether any of the grouping expressions aren't simple Vars; if
     * they're all Vars then we don't have to work so hard in the recursive
     * scans.  (Note we have to flatten aliases before this.)
     *
     * Track Vars that are included in all grouping sets separately in
     * groupClauseCommonVars, since these are the only ones we can use to
     * check for functional dependencies.
     */
    have_non_var_grouping = false;
    foreach(l, groupClauses)
    {
        TargetEntry *tle = lfirst(l);
 
        if (!IsA(tle->expr, Var))
        {
            have_non_var_grouping = true;
        }
        else if (!qry->groupingSets ||
                 list_member_int(gset_common, tle->ressortgroupref))
        {
            groupClauseCommonVars = lappend(groupClauseCommonVars, tle->expr);
        }
    }
 
    /*
     * If there are any acceptable GROUP BY expressions, build an RTE and
     * nsitem for the result of the grouping step.
     */
    if (groupClauses)
    {
        pstate->p_grouping_nsitem =
            addRangeTableEntryForGroup(pstate, groupClauses);
 
        /* Set qry->rtable again in case it was previously NIL */
        qry->rtable = pstate->p_rtable;
        /* Mark the Query as having RTE_GROUP RTE */
        qry->hasGroupRTE = true;
    }
 
    /*
     * Replace grouped variables in the targetlist and HAVING clause with Vars
     * that reference the RTE_GROUP RTE.  Emit an error message if we find any
     * ungrouped variables.
     *
     * Note: because we check resjunk tlist elements as well as regular ones,
     * this will also find ungrouped variables that came from ORDER BY and
     * WINDOW clauses.  For that matter, it's also going to examine the
     * grouping expressions themselves --- but they'll all pass the test ...
     *
     * We also finalize GROUPING expressions, but for that we need to traverse
     * the original (unflattened) clause in order to modify nodes.
     */
    clause = (Node *) qry->targetList;
    finalize_grouping_exprs(clause, pstate, qry,
                            groupClauses, hasJoinRTEs,
                            have_non_var_grouping);
    if (hasJoinRTEs)
        clause = flatten_join_alias_vars(NULL, qry, clause);
    qry->targetList = (List *)
        substitute_grouped_columns(clause, pstate, qry,
                                   groupClauses, groupClauseCommonVars,
                                   gset_common,
                                   have_non_var_grouping,
                                   &func_grouped_rels);
 
    clause = (Node *) qry->havingQual;
    finalize_grouping_exprs(clause, pstate, qry,
                            groupClauses, hasJoinRTEs,
                            have_non_var_grouping);
    if (hasJoinRTEs)
        clause = flatten_join_alias_vars(NULL, qry, clause);
    qry->havingQual =
        substitute_grouped_columns(clause, pstate, qry,
                                   groupClauses, groupClauseCommonVars,
                                   gset_common,
                                   have_non_var_grouping,
                                   &func_grouped_rels);
 
    /*
     * Per spec, aggregates can't appear in a recursive term.
     */
    if (pstate->p_hasAggs && hasSelfRefRTEs)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_RECURSION),
                 errmsg("aggregate functions are not allowed in a recursive query's recursive term"),
                 parser_errposition(pstate,
                                    locate_agg_of_level((Node *) qry, 0))));
}

References addRangeTableEntryForGroup(), Assert(), ereport, errcode(), errmsg(), ERROR, expand_grouping_sets(), TargetEntry::expr, exprLocation(), finalize_grouping_exprs(), flatten_join_alias_vars(), for_each_from, get_sortgroupclause_tle(), Query::groupClause, Query::groupDistinct, Query::groupingSets, Query::havingQual, IsA, lappend(), lfirst, linitial, list_intersection_int(), list_length(), list_member_int(), locate_agg_of_level(), NIL, ParseState::p_grouping_nsitem, ParseState::p_hasAggs, ParseState::p_rtable, parser_errposition(), TargetEntry::ressortgroupref, Query::rtable, RTE_CTE, RTE_JOIN, RangeTblEntry::rtekind, substitute_grouped_columns(), and Query::targetList.

Referenced by transformDeleteStmt(), transformPLAssignStmt(), transformSelectStmt(), and transformSetOperationStmt().

resolve_aggregate_transtype()

Oid resolve_aggregate_transtype	(	Oid	aggfuncid,
		Oid	aggtranstype,
		Oid *	inputTypes,
		int	numArguments
	)

Definition at line 2023 of file parse_agg.c.

{
    /* resolve actual type of transition state, if polymorphic */
    if (IsPolymorphicType(aggtranstype))
    {
        /* have to fetch the agg's declared input types... */
        Oid        *declaredArgTypes;
        int         agg_nargs;
 
        (void) get_func_signature(aggfuncid, &declaredArgTypes, &agg_nargs);
 
        /*
         * VARIADIC ANY aggs could have more actual than declared args, but
         * such extra args can't affect polymorphic type resolution.
         */
        Assert(agg_nargs <= numArguments);
 
        aggtranstype = enforce_generic_type_consistency(inputTypes,
                                                        declaredArgTypes,
                                                        agg_nargs,
                                                        aggtranstype,
                                                        false);
        pfree(declaredArgTypes);
    }
    return aggtranstype;
}

References Assert(), enforce_generic_type_consistency(), get_func_signature(), and pfree().

Referenced by initialize_peragg(), and preprocess_aggref().

transformAggregateCall()

void transformAggregateCall	(	ParseState *	pstate,
		Aggref *	agg,
		List *	args,
		List *	aggorder,
		bool	agg_distinct
	)

Definition at line 109 of file parse_agg.c.

{
    List       *argtypes = NIL;
    List       *tlist = NIL;
    List       *torder = NIL;
    List       *tdistinct = NIL;
    AttrNumber  attno = 1;
    int         save_next_resno;
    ListCell   *lc;
 
    if (AGGKIND_IS_ORDERED_SET(agg->aggkind))
    {
        /*
         * For an ordered-set agg, the args list includes direct args and
         * aggregated args; we must split them apart.
         */
        int         numDirectArgs = list_length(args) - list_length(aggorder);
        List       *aargs;
        ListCell   *lc2;
 
        Assert(numDirectArgs >= 0);
 
        aargs = list_copy_tail(args, numDirectArgs);
        agg->aggdirectargs = list_truncate(args, numDirectArgs);
 
        /*
         * Build a tlist from the aggregated args, and make a sortlist entry
         * for each one.  Note that the expressions in the SortBy nodes are
         * ignored (they are the raw versions of the transformed args); we are
         * just looking at the sort information in the SortBy nodes.
         */
        forboth(lc, aargs, lc2, aggorder)
        {
            Expr       *arg = (Expr *) lfirst(lc);
            SortBy     *sortby = (SortBy *) lfirst(lc2);
            TargetEntry *tle;
 
            /* We don't bother to assign column names to the entries */
            tle = makeTargetEntry(arg, attno++, NULL, false);
            tlist = lappend(tlist, tle);
 
            torder = addTargetToSortList(pstate, tle,
                                         torder, tlist, sortby);
        }
 
        /* Never any DISTINCT in an ordered-set agg */
        Assert(!agg_distinct);
    }
    else
    {
        /* Regular aggregate, so it has no direct args */
        agg->aggdirectargs = NIL;
 
        /*
         * Transform the plain list of Exprs into a targetlist.
         */
        foreach(lc, args)
        {
            Expr       *arg = (Expr *) lfirst(lc);
            TargetEntry *tle;
 
            /* We don't bother to assign column names to the entries */
            tle = makeTargetEntry(arg, attno++, NULL, false);
            tlist = lappend(tlist, tle);
        }
 
        /*
         * If we have an ORDER BY, transform it.  This will add columns to the
         * tlist if they appear in ORDER BY but weren't already in the arg
         * list.  They will be marked resjunk = true so we can tell them apart
         * from regular aggregate arguments later.
         *
         * We need to mess with p_next_resno since it will be used to number
         * any new targetlist entries.
         */
        save_next_resno = pstate->p_next_resno;
        pstate->p_next_resno = attno;
 
        torder = transformSortClause(pstate,
                                     aggorder,
                                     &tlist,
                                     EXPR_KIND_ORDER_BY,
                                     true /* force SQL99 rules */ );
 
        /*
         * If we have DISTINCT, transform that to produce a distinctList.
         */
        if (agg_distinct)
        {
            tdistinct = transformDistinctClause(pstate, &tlist, torder, true);
 
            /*
             * Remove this check if executor support for hashed distinct for
             * aggregates is ever added.
             */
            foreach(lc, tdistinct)
            {
                SortGroupClause *sortcl = (SortGroupClause *) lfirst(lc);
 
                if (!OidIsValid(sortcl->sortop))
                {
                    Node       *expr = get_sortgroupclause_expr(sortcl, tlist);
 
                    ereport(ERROR,
                            (errcode(ERRCODE_UNDEFINED_FUNCTION),
                             errmsg("could not identify an ordering operator for type %s",
                                    format_type_be(exprType(expr))),
                             errdetail("Aggregates with DISTINCT must be able to sort their inputs."),
                             parser_errposition(pstate, exprLocation(expr))));
                }
            }
        }
 
        pstate->p_next_resno = save_next_resno;
    }
 
    /* Update the Aggref with the transformation results */
    agg->args = tlist;
    agg->aggorder = torder;
    agg->aggdistinct = tdistinct;
 
    /*
     * Now build the aggargtypes list with the type OIDs of the direct and
     * aggregated args, ignoring any resjunk entries that might have been
     * added by ORDER BY/DISTINCT processing.  We can't do this earlier
     * because said processing can modify some args' data types, in particular
     * by resolving previously-unresolved "unknown" literals.
     */
    foreach(lc, agg->aggdirectargs)
    {
        Expr       *arg = (Expr *) lfirst(lc);
 
        argtypes = lappend_oid(argtypes, exprType((Node *) arg));
    }
    foreach(lc, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(lc);
 
        if (tle->resjunk)
            continue;           /* ignore junk */
        argtypes = lappend_oid(argtypes, exprType((Node *) tle->expr));
    }
    agg->aggargtypes = argtypes;
 
    check_agglevels_and_constraints(pstate, (Node *) agg);
}

References addTargetToSortList(), Aggref::aggdirectargs, Aggref::aggdistinct, Aggref::aggorder, arg, generate_unaccent_rules::args, Aggref::args, Assert(), check_agglevels_and_constraints(), ereport, errcode(), errdetail(), errmsg(), ERROR, TargetEntry::expr, EXPR_KIND_ORDER_BY, exprLocation(), exprType(), forboth, format_type_be(), get_sortgroupclause_expr(), lappend(), lappend_oid(), lfirst, list_copy_tail(), list_length(), list_truncate(), makeTargetEntry(), NIL, OidIsValid, ParseState::p_next_resno, parser_errposition(), SortGroupClause::sortop, transformDistinctClause(), and transformSortClause().

Referenced by ParseFuncOrColumn(), and transformJsonAggConstructor().

transformGroupingFunc()

Node * transformGroupingFunc	(	ParseState *	pstate,
		GroupingFunc *	p
	)

Definition at line 265 of file parse_agg.c.

{
    ListCell   *lc;
    List       *args = p->args;
    List       *result_list = NIL;
    GroupingFunc *result = makeNode(GroupingFunc);
 
    if (list_length(args) > 31)
        ereport(ERROR,
                (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
                 errmsg("GROUPING must have fewer than 32 arguments"),
                 parser_errposition(pstate, p->location)));
 
    foreach(lc, args)
    {
        Node       *current_result;
 
        current_result = transformExpr(pstate, (Node *) lfirst(lc), pstate->p_expr_kind);
 
        /* acceptability of expressions is checked later */
 
        result_list = lappend(result_list, current_result);
    }
 
    result->args = result_list;
    result->location = p->location;
 
    check_agglevels_and_constraints(pstate, (Node *) result);
 
    return (Node *) result;
}

References generate_unaccent_rules::args, check_agglevels_and_constraints(), ereport, errcode(), errmsg(), ERROR, lappend(), lfirst, list_length(), GroupingFunc::location, makeNode, NIL, ParseState::p_expr_kind, parser_errposition(), and transformExpr().

Referenced by transformExprRecurse().

transformWindowFuncCall()

void transformWindowFuncCall	(	ParseState *	pstate,
		WindowFunc *	wfunc,
		WindowDef *	windef
	)

Definition at line 825 of file parse_agg.c.

{
    const char *err;
    bool        errkind;
 
    /*
     * A window function call can't contain another one (but aggs are OK). XXX
     * is this required by spec, or just an unimplemented feature?
     *
     * Note: we don't need to check the filter expression here, because the
     * context checks done below and in transformAggregateCall would have
     * already rejected any window funcs or aggs within the filter.
     */
    if (pstate->p_hasWindowFuncs &&
        contain_windowfuncs((Node *) wfunc->args))
        ereport(ERROR,
                (errcode(ERRCODE_WINDOWING_ERROR),
                 errmsg("window function calls cannot be nested"),
                 parser_errposition(pstate,
                                    locate_windowfunc((Node *) wfunc->args))));
 
    /*
     * Check to see if the window function is in an invalid place within the
     * query.
     *
     * For brevity we support two schemes for reporting an error here: set
     * "err" to a custom message, or set "errkind" true if the error context
     * is sufficiently identified by what ParseExprKindName will return, *and*
     * what it will return is just a SQL keyword.  (Otherwise, use a custom
     * message to avoid creating translation problems.)
     */
    err = NULL;
    errkind = false;
    switch (pstate->p_expr_kind)
    {
        case EXPR_KIND_NONE:
            Assert(false);      /* can't happen */
            break;
        case EXPR_KIND_OTHER:
            /* Accept window func here; caller must throw error if wanted */
            break;
        case EXPR_KIND_JOIN_ON:
        case EXPR_KIND_JOIN_USING:
            err = _("window functions are not allowed in JOIN conditions");
            break;
        case EXPR_KIND_FROM_SUBSELECT:
            /* can't get here, but just in case, throw an error */
            errkind = true;
            break;
        case EXPR_KIND_FROM_FUNCTION:
            err = _("window functions are not allowed in functions in FROM");
            break;
        case EXPR_KIND_WHERE:
            errkind = true;
            break;
        case EXPR_KIND_POLICY:
            err = _("window functions are not allowed in policy expressions");
            break;
        case EXPR_KIND_HAVING:
            errkind = true;
            break;
        case EXPR_KIND_FILTER:
            errkind = true;
            break;
        case EXPR_KIND_WINDOW_PARTITION:
        case EXPR_KIND_WINDOW_ORDER:
        case EXPR_KIND_WINDOW_FRAME_RANGE:
        case EXPR_KIND_WINDOW_FRAME_ROWS:
        case EXPR_KIND_WINDOW_FRAME_GROUPS:
            err = _("window functions are not allowed in window definitions");
            break;
        case EXPR_KIND_SELECT_TARGET:
            /* okay */
            break;
        case EXPR_KIND_INSERT_TARGET:
        case EXPR_KIND_UPDATE_SOURCE:
        case EXPR_KIND_UPDATE_TARGET:
            errkind = true;
            break;
        case EXPR_KIND_MERGE_WHEN:
            err = _("window functions are not allowed in MERGE WHEN conditions");
            break;
        case EXPR_KIND_GROUP_BY:
            errkind = true;
            break;
        case EXPR_KIND_ORDER_BY:
            /* okay */
            break;
        case EXPR_KIND_DISTINCT_ON:
            /* okay */
            break;
        case EXPR_KIND_LIMIT:
        case EXPR_KIND_OFFSET:
            errkind = true;
            break;
        case EXPR_KIND_RETURNING:
        case EXPR_KIND_MERGE_RETURNING:
            errkind = true;
            break;
        case EXPR_KIND_VALUES:
        case EXPR_KIND_VALUES_SINGLE:
            errkind = true;
            break;
        case EXPR_KIND_CHECK_CONSTRAINT:
        case EXPR_KIND_DOMAIN_CHECK:
            err = _("window functions are not allowed in check constraints");
            break;
        case EXPR_KIND_COLUMN_DEFAULT:
        case EXPR_KIND_FUNCTION_DEFAULT:
            err = _("window functions are not allowed in DEFAULT expressions");
            break;
        case EXPR_KIND_INDEX_EXPRESSION:
            err = _("window functions are not allowed in index expressions");
            break;
        case EXPR_KIND_STATS_EXPRESSION:
            err = _("window functions are not allowed in statistics expressions");
            break;
        case EXPR_KIND_INDEX_PREDICATE:
            err = _("window functions are not allowed in index predicates");
            break;
        case EXPR_KIND_ALTER_COL_TRANSFORM:
            err = _("window functions are not allowed in transform expressions");
            break;
        case EXPR_KIND_EXECUTE_PARAMETER:
            err = _("window functions are not allowed in EXECUTE parameters");
            break;
        case EXPR_KIND_TRIGGER_WHEN:
            err = _("window functions are not allowed in trigger WHEN conditions");
            break;
        case EXPR_KIND_PARTITION_BOUND:
            err = _("window functions are not allowed in partition bound");
            break;
        case EXPR_KIND_PARTITION_EXPRESSION:
            err = _("window functions are not allowed in partition key expressions");
            break;
        case EXPR_KIND_CALL_ARGUMENT:
            err = _("window functions are not allowed in CALL arguments");
            break;
        case EXPR_KIND_COPY_WHERE:
            err = _("window functions are not allowed in COPY FROM WHERE conditions");
            break;
        case EXPR_KIND_GENERATED_COLUMN:
            err = _("window functions are not allowed in column generation expressions");
            break;
        case EXPR_KIND_CYCLE_MARK:
            errkind = true;
            break;
 
            /*
             * There is intentionally no default: case here, so that the
             * compiler will warn if we add a new ParseExprKind without
             * extending this switch.  If we do see an unrecognized value at
             * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
             * which is sane anyway.
             */
    }
    if (err)
        ereport(ERROR,
                (errcode(ERRCODE_WINDOWING_ERROR),
                 errmsg_internal("%s", err),
                 parser_errposition(pstate, wfunc->location)));
    if (errkind)
        ereport(ERROR,
                (errcode(ERRCODE_WINDOWING_ERROR),
        /* translator: %s is name of a SQL construct, eg GROUP BY */
                 errmsg("window functions are not allowed in %s",
                        ParseExprKindName(pstate->p_expr_kind)),
                 parser_errposition(pstate, wfunc->location)));
 
    /*
     * If the OVER clause just specifies a window name, find that WINDOW
     * clause (which had better be present).  Otherwise, try to match all the
     * properties of the OVER clause, and make a new entry in the p_windowdefs
     * list if no luck.
     */
    if (windef->name)
    {
        Index       winref = 0;
        ListCell   *lc;
 
        Assert(windef->refname == NULL &&
               windef->partitionClause == NIL &&
               windef->orderClause == NIL &&
               windef->frameOptions == FRAMEOPTION_DEFAULTS);
 
        foreach(lc, pstate->p_windowdefs)
        {
            WindowDef  *refwin = (WindowDef *) lfirst(lc);
 
            winref++;
            if (refwin->name && strcmp(refwin->name, windef->name) == 0)
            {
                wfunc->winref = winref;
                break;
            }
        }
        if (lc == NULL)         /* didn't find it? */
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("window \"%s\" does not exist", windef->name),
                     parser_errposition(pstate, windef->location)));
    }
    else
    {
        Index       winref = 0;
        ListCell   *lc;
 
        foreach(lc, pstate->p_windowdefs)
        {
            WindowDef  *refwin = (WindowDef *) lfirst(lc);
 
            winref++;
            if (refwin->refname && windef->refname &&
                strcmp(refwin->refname, windef->refname) == 0)
                 /* matched on refname */ ;
            else if (!refwin->refname && !windef->refname)
                 /* matched, no refname */ ;
            else
                continue;
 
            /*
             * Also see similar de-duplication code in optimize_window_clauses
             */
            if (equal(refwin->partitionClause, windef->partitionClause) &&
                equal(refwin->orderClause, windef->orderClause) &&
                refwin->frameOptions == windef->frameOptions &&
                equal(refwin->startOffset, windef->startOffset) &&
                equal(refwin->endOffset, windef->endOffset))
            {
                /* found a duplicate window specification */
                wfunc->winref = winref;
                break;
            }
        }
        if (lc == NULL)         /* didn't find it? */
        {
            pstate->p_windowdefs = lappend(pstate->p_windowdefs, windef);
            wfunc->winref = list_length(pstate->p_windowdefs);
        }
    }
 
    pstate->p_hasWindowFuncs = true;
}

References _, WindowFunc::args, Assert(), contain_windowfuncs(), WindowDef::endOffset, equal(), ereport, err(), errcode(), errmsg(), errmsg_internal(), ERROR, EXPR_KIND_ALTER_COL_TRANSFORM, EXPR_KIND_CALL_ARGUMENT, EXPR_KIND_CHECK_CONSTRAINT, EXPR_KIND_COLUMN_DEFAULT, EXPR_KIND_COPY_WHERE, EXPR_KIND_CYCLE_MARK, EXPR_KIND_DISTINCT_ON, EXPR_KIND_DOMAIN_CHECK, EXPR_KIND_EXECUTE_PARAMETER, EXPR_KIND_FILTER, EXPR_KIND_FROM_FUNCTION, EXPR_KIND_FROM_SUBSELECT, EXPR_KIND_FUNCTION_DEFAULT, EXPR_KIND_GENERATED_COLUMN, EXPR_KIND_GROUP_BY, EXPR_KIND_HAVING, EXPR_KIND_INDEX_EXPRESSION, EXPR_KIND_INDEX_PREDICATE, EXPR_KIND_INSERT_TARGET, EXPR_KIND_JOIN_ON, EXPR_KIND_JOIN_USING, EXPR_KIND_LIMIT, EXPR_KIND_MERGE_RETURNING, EXPR_KIND_MERGE_WHEN, EXPR_KIND_NONE, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, EXPR_KIND_OTHER, EXPR_KIND_PARTITION_BOUND, EXPR_KIND_PARTITION_EXPRESSION, EXPR_KIND_POLICY, EXPR_KIND_RETURNING, EXPR_KIND_SELECT_TARGET, EXPR_KIND_STATS_EXPRESSION, EXPR_KIND_TRIGGER_WHEN, EXPR_KIND_UPDATE_SOURCE, EXPR_KIND_UPDATE_TARGET, EXPR_KIND_VALUES, EXPR_KIND_VALUES_SINGLE, EXPR_KIND_WHERE, EXPR_KIND_WINDOW_FRAME_GROUPS, EXPR_KIND_WINDOW_FRAME_RANGE, EXPR_KIND_WINDOW_FRAME_ROWS, EXPR_KIND_WINDOW_ORDER, EXPR_KIND_WINDOW_PARTITION, FRAMEOPTION_DEFAULTS, WindowDef::frameOptions, lappend(), lfirst, list_length(), locate_windowfunc(), WindowDef::location, WindowFunc::location, WindowDef::name, NIL, WindowDef::orderClause, ParseState::p_expr_kind, ParseState::p_hasWindowFuncs, ParseState::p_windowdefs, ParseExprKindName(), parser_errposition(), WindowDef::partitionClause, WindowDef::refname, WindowDef::startOffset, and WindowFunc::winref.

Referenced by ParseFuncOrColumn(), and transformJsonAggConstructor().