PostgreSQL Source Code  git master
parse_agg.h File Reference
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)
 
NodetransformGroupingFunc (ParseState *pstate, GroupingFunc *g)
 
void transformWindowFuncCall (ParseState *pstate, WindowFunc *wfunc, WindowDef *windef)
 
void parseCheckAggregates (ParseState *pstate, Query *qry)
 
Listexpand_grouping_sets (List *groupingSets, int limit)
 
int get_aggregate_argtypes (Aggref *aggref, Oid *inputTypes)
 
Oid resolve_aggregate_transtype (Oid aggfuncid, Oid aggtranstype, Oid *inputTypes, int numArguments)
 
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_combinefn_expr (Oid agg_state_type, Oid agg_input_collation, Oid combinefn_oid, Expr **combinefnexpr)
 
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

◆ build_aggregate_combinefn_expr()

void build_aggregate_combinefn_expr ( Oid  agg_state_type,
Oid  agg_input_collation,
Oid  combinefn_oid,
Expr **  combinefnexpr 
)

Definition at line 1962 of file parse_agg.c.

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

Referenced by build_pertrans_for_aggref().

1966 {
1967  Node *argp;
1968  List *args;
1969  FuncExpr *fexpr;
1970 
1971  /* combinefn takes two arguments of the aggregate state type */
1972  argp = make_agg_arg(agg_state_type, agg_input_collation);
1973 
1974  args = list_make2(argp, argp);
1975 
1976  fexpr = makeFuncExpr(combinefn_oid,
1977  agg_state_type,
1978  args,
1979  InvalidOid,
1980  agg_input_collation,
1982  /* combinefn is currently never treated as variadic */
1983  *combinefnexpr = (Expr *) fexpr;
1984 }
#define list_make2(x1, x2)
Definition: pg_list.h:140
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2078
Definition: nodes.h:517
#define InvalidOid
Definition: postgres_ext.h:36
Definition: pg_list.h:45
FuncExpr * makeFuncExpr(Oid funcid, Oid rettype, List *args, Oid funccollid, Oid inputcollid, CoercionForm fformat)
Definition: makefuncs.c:519

◆ build_aggregate_deserialfn_expr()

void build_aggregate_deserialfn_expr ( Oid  deserialfn_oid,
Expr **  deserialfnexpr 
)

Definition at line 2014 of file parse_agg.c.

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

Referenced by build_pertrans_for_aggref().

2016 {
2017  List *args;
2018  FuncExpr *fexpr;
2019 
2020  /* deserialfn always takes BYTEA, INTERNAL and returns INTERNAL */
2021  args = list_make2(make_agg_arg(BYTEAOID, InvalidOid),
2022  make_agg_arg(INTERNALOID, InvalidOid));
2023 
2024  fexpr = makeFuncExpr(deserialfn_oid,
2025  INTERNALOID,
2026  args,
2027  InvalidOid,
2028  InvalidOid,
2030  *deserialfnexpr = (Expr *) fexpr;
2031 }
#define list_make2(x1, x2)
Definition: pg_list.h:140
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2078
#define InvalidOid
Definition: postgres_ext.h:36
Definition: pg_list.h:45
FuncExpr * makeFuncExpr(Oid funcid, Oid rettype, List *args, Oid funccollid, Oid inputcollid, CoercionForm fformat)
Definition: makefuncs.c:519

◆ 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 2038 of file parse_agg.c.

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

Referenced by ExecInitAgg(), and initialize_peragg().

2045 {
2046  List *args;
2047  int i;
2048 
2049  /*
2050  * Build expr tree for final function
2051  */
2052  args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
2053 
2054  /* finalfn may take additional args, which match agg's input types */
2055  for (i = 0; i < num_finalfn_inputs - 1; i++)
2056  {
2057  args = lappend(args,
2058  make_agg_arg(agg_input_types[i], agg_input_collation));
2059  }
2060 
2061  *finalfnexpr = (Expr *) makeFuncExpr(finalfn_oid,
2062  agg_result_type,
2063  args,
2064  InvalidOid,
2065  agg_input_collation,
2067  /* finalfn is currently never treated as variadic */
2068 }
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2078
#define list_make1(x1)
Definition: pg_list.h:139
List * lappend(List *list, void *datum)
Definition: list.c:128
#define InvalidOid
Definition: postgres_ext.h:36
int i
Definition: pg_list.h:45
FuncExpr * makeFuncExpr(Oid funcid, Oid rettype, List *args, Oid funccollid, Oid inputcollid, CoercionForm fformat)
Definition: makefuncs.c:519

◆ build_aggregate_serialfn_expr()

void build_aggregate_serialfn_expr ( Oid  serialfn_oid,
Expr **  serialfnexpr 
)

Definition at line 1991 of file parse_agg.c.

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

Referenced by build_pertrans_for_aggref().

1993 {
1994  List *args;
1995  FuncExpr *fexpr;
1996 
1997  /* serialfn always takes INTERNAL and returns BYTEA */
1998  args = list_make1(make_agg_arg(INTERNALOID, InvalidOid));
1999 
2000  fexpr = makeFuncExpr(serialfn_oid,
2001  BYTEAOID,
2002  args,
2003  InvalidOid,
2004  InvalidOid,
2006  *serialfnexpr = (Expr *) fexpr;
2007 }
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2078
#define list_make1(x1)
Definition: pg_list.h:139
#define InvalidOid
Definition: postgres_ext.h:36
Definition: pg_list.h:45
FuncExpr * makeFuncExpr(Oid funcid, Oid rettype, List *args, Oid funccollid, Oid inputcollid, CoercionForm fformat)
Definition: makefuncs.c:519

◆ 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 1901 of file parse_agg.c.

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

Referenced by build_pertrans_for_aggref(), and initialize_peragg().

1911 {
1912  List *args;
1913  FuncExpr *fexpr;
1914  int i;
1915 
1916  /*
1917  * Build arg list to use in the transfn FuncExpr node.
1918  */
1919  args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
1920 
1921  for (i = agg_num_direct_inputs; i < agg_num_inputs; i++)
1922  {
1923  args = lappend(args,
1924  make_agg_arg(agg_input_types[i], agg_input_collation));
1925  }
1926 
1927  fexpr = makeFuncExpr(transfn_oid,
1928  agg_state_type,
1929  args,
1930  InvalidOid,
1931  agg_input_collation,
1933  fexpr->funcvariadic = agg_variadic;
1934  *transfnexpr = (Expr *) fexpr;
1935 
1936  /*
1937  * Build invtransfn expression if requested, with same args as transfn
1938  */
1939  if (invtransfnexpr != NULL)
1940  {
1941  if (OidIsValid(invtransfn_oid))
1942  {
1943  fexpr = makeFuncExpr(invtransfn_oid,
1944  agg_state_type,
1945  args,
1946  InvalidOid,
1947  agg_input_collation,
1949  fexpr->funcvariadic = agg_variadic;
1950  *invtransfnexpr = (Expr *) fexpr;
1951  }
1952  else
1953  *invtransfnexpr = NULL;
1954  }
1955 }
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2078
#define OidIsValid(objectId)
Definition: c.h:605
#define list_make1(x1)
Definition: pg_list.h:139
List * lappend(List *list, void *datum)
Definition: list.c:128
#define InvalidOid
Definition: postgres_ext.h:36
int i
Definition: pg_list.h:45
bool funcvariadic
Definition: primnodes.h:453
FuncExpr * makeFuncExpr(Oid funcid, Oid rettype, List *args, Oid funccollid, Oid inputcollid, CoercionForm fformat)
Definition: makefuncs.c:519

◆ expand_grouping_sets()

List* expand_grouping_sets ( List groupingSets,
int  limit 
)

Definition at line 1721 of file parse_agg.c.

References Assert, buf, cmp_list_len_asc(), expand_groupingset_node(), for_each_cell, lappend(), lfirst, linitial, list_head(), list_length(), list_union_int(), lnext, NIL, palloc(), pfree(), and qsort.

Referenced by parseCheckAggregates(), and preprocess_grouping_sets().

1722 {
1723  List *expanded_groups = NIL;
1724  List *result = NIL;
1725  double numsets = 1;
1726  ListCell *lc;
1727 
1728  if (groupingSets == NIL)
1729  return NIL;
1730 
1731  foreach(lc, groupingSets)
1732  {
1733  List *current_result = NIL;
1734  GroupingSet *gs = lfirst(lc);
1735 
1736  current_result = expand_groupingset_node(gs);
1737 
1738  Assert(current_result != NIL);
1739 
1740  numsets *= list_length(current_result);
1741 
1742  if (limit >= 0 && numsets > limit)
1743  return NIL;
1744 
1745  expanded_groups = lappend(expanded_groups, current_result);
1746  }
1747 
1748  /*
1749  * Do cartesian product between sublists of expanded_groups. While at it,
1750  * remove any duplicate elements from individual grouping sets (we must
1751  * NOT change the number of sets though)
1752  */
1753 
1754  foreach(lc, (List *) linitial(expanded_groups))
1755  {
1756  result = lappend(result, list_union_int(NIL, (List *) lfirst(lc)));
1757  }
1758 
1759  for_each_cell(lc, lnext(list_head(expanded_groups)))
1760  {
1761  List *p = lfirst(lc);
1762  List *new_result = NIL;
1763  ListCell *lc2;
1764 
1765  foreach(lc2, result)
1766  {
1767  List *q = lfirst(lc2);
1768  ListCell *lc3;
1769 
1770  foreach(lc3, p)
1771  {
1772  new_result = lappend(new_result,
1773  list_union_int(q, (List *) lfirst(lc3)));
1774  }
1775  }
1776  result = new_result;
1777  }
1778 
1779  if (list_length(result) > 1)
1780  {
1781  int result_len = list_length(result);
1782  List **buf = palloc(sizeof(List *) * result_len);
1783  List **ptr = buf;
1784 
1785  foreach(lc, result)
1786  {
1787  *ptr++ = lfirst(lc);
1788  }
1789 
1790  qsort(buf, result_len, sizeof(List *), cmp_list_len_asc);
1791 
1792  result = NIL;
1793  ptr = buf;
1794 
1795  while (result_len-- > 0)
1796  result = lappend(result, *ptr++);
1797 
1798  pfree(buf);
1799  }
1800 
1801  return result;
1802 }
static int cmp_list_len_asc(const void *a, const void *b)
Definition: parse_agg.c:1705
#define NIL
Definition: pg_list.h:69
void pfree(void *pointer)
Definition: mcxt.c:1031
#define linitial(l)
Definition: pg_list.h:111
static List * expand_groupingset_node(GroupingSet *gs)
Definition: parse_agg.c:1600
static char * buf
Definition: pg_test_fsync.c:67
List * list_union_int(const List *list1, const List *list2)
Definition: list.c:744
static ListCell * list_head(const List *l)
Definition: pg_list.h:77
#define lnext(lc)
Definition: pg_list.h:105
List * lappend(List *list, void *datum)
Definition: list.c:128
#define Assert(condition)
Definition: c.h:699
#define lfirst(lc)
Definition: pg_list.h:106
static int list_length(const List *l)
Definition: pg_list.h:89
#define for_each_cell(cell, initcell)
Definition: pg_list.h:169
void * palloc(Size size)
Definition: mcxt.c:924
#define qsort(a, b, c, d)
Definition: port.h:421
Definition: pg_list.h:45

◆ get_aggregate_argtypes()

int get_aggregate_argtypes ( Aggref aggref,
Oid inputTypes 
)

Definition at line 1820 of file parse_agg.c.

References Aggref::aggargtypes, Assert, FUNC_MAX_ARGS, lfirst_oid, and list_length().

Referenced by ExecInitAgg(), get_agg_clause_costs_walker(), and get_agg_expr().

1821 {
1822  int numArguments = 0;
1823  ListCell *lc;
1824 
1826 
1827  foreach(lc, aggref->aggargtypes)
1828  {
1829  inputTypes[numArguments++] = lfirst_oid(lc);
1830  }
1831 
1832  return numArguments;
1833 }
#define FUNC_MAX_ARGS
List * aggargtypes
Definition: primnodes.h:300
#define Assert(condition)
Definition: c.h:699
static int list_length(const List *l)
Definition: pg_list.h:89
#define lfirst_oid(lc)
Definition: pg_list.h:108

◆ parseCheckAggregates()

void parseCheckAggregates ( ParseState pstate,
Query qry 
)

Definition at line 1011 of file parse_agg.c.

References Assert, check_ungrouped_columns(), CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, expand_grouping_sets(), TargetEntry::expr, exprLocation(), finalize_grouping_exprs(), flatten_join_alias_vars(), for_each_cell, get_sortgroupclause_tle(), Query::groupClause, Query::groupingSets, PlannerInfo::hasJoinRTEs, Query::havingQual, IsA, lappend(), lcons(), lfirst, linitial, list_head(), list_intersection_int(), list_length(), list_member_int(), lnext, locate_agg_of_level(), makeNode, NIL, ParseState::p_hasAggs, ParseState::p_rtable, PlannerInfo::parse, parser_errposition(), PlannerInfo::planner_cxt, TargetEntry::ressortgroupref, RTE_CTE, RTE_JOIN, RangeTblEntry::rtekind, RangeTblEntry::self_reference, and Query::targetList.

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

1012 {
1013  List *gset_common = NIL;
1014  List *groupClauses = NIL;
1015  List *groupClauseCommonVars = NIL;
1016  bool have_non_var_grouping;
1017  List *func_grouped_rels = NIL;
1018  ListCell *l;
1019  bool hasJoinRTEs;
1020  bool hasSelfRefRTEs;
1021  PlannerInfo *root = NULL;
1022  Node *clause;
1023 
1024  /* This should only be called if we found aggregates or grouping */
1025  Assert(pstate->p_hasAggs || qry->groupClause || qry->havingQual || qry->groupingSets);
1026 
1027  /*
1028  * If we have grouping sets, expand them and find the intersection of all
1029  * sets.
1030  */
1031  if (qry->groupingSets)
1032  {
1033  /*
1034  * The limit of 4096 is arbitrary and exists simply to avoid resource
1035  * issues from pathological constructs.
1036  */
1037  List *gsets = expand_grouping_sets(qry->groupingSets, 4096);
1038 
1039  if (!gsets)
1040  ereport(ERROR,
1041  (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
1042  errmsg("too many grouping sets present (maximum 4096)"),
1043  parser_errposition(pstate,
1044  qry->groupClause
1045  ? exprLocation((Node *) qry->groupClause)
1046  : exprLocation((Node *) qry->groupingSets))));
1047 
1048  /*
1049  * The intersection will often be empty, so help things along by
1050  * seeding the intersect with the smallest set.
1051  */
1052  gset_common = linitial(gsets);
1053 
1054  if (gset_common)
1055  {
1056  for_each_cell(l, lnext(list_head(gsets)))
1057  {
1058  gset_common = list_intersection_int(gset_common, lfirst(l));
1059  if (!gset_common)
1060  break;
1061  }
1062  }
1063 
1064  /*
1065  * If there was only one grouping set in the expansion, AND if the
1066  * groupClause is non-empty (meaning that the grouping set is not
1067  * empty either), then we can ditch the grouping set and pretend we
1068  * just had a normal GROUP BY.
1069  */
1070  if (list_length(gsets) == 1 && qry->groupClause)
1071  qry->groupingSets = NIL;
1072  }
1073 
1074  /*
1075  * Scan the range table to see if there are JOIN or self-reference CTE
1076  * entries. We'll need this info below.
1077  */
1078  hasJoinRTEs = hasSelfRefRTEs = false;
1079  foreach(l, pstate->p_rtable)
1080  {
1081  RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
1082 
1083  if (rte->rtekind == RTE_JOIN)
1084  hasJoinRTEs = true;
1085  else if (rte->rtekind == RTE_CTE && rte->self_reference)
1086  hasSelfRefRTEs = true;
1087  }
1088 
1089  /*
1090  * Build a list of the acceptable GROUP BY expressions for use by
1091  * check_ungrouped_columns().
1092  *
1093  * We get the TLE, not just the expr, because GROUPING wants to know the
1094  * sortgroupref.
1095  */
1096  foreach(l, qry->groupClause)
1097  {
1098  SortGroupClause *grpcl = (SortGroupClause *) lfirst(l);
1099  TargetEntry *expr;
1100 
1101  expr = get_sortgroupclause_tle(grpcl, qry->targetList);
1102  if (expr == NULL)
1103  continue; /* probably cannot happen */
1104 
1105  groupClauses = lcons(expr, groupClauses);
1106  }
1107 
1108  /*
1109  * If there are join alias vars involved, we have to flatten them to the
1110  * underlying vars, so that aliased and unaliased vars will be correctly
1111  * taken as equal. We can skip the expense of doing this if no rangetable
1112  * entries are RTE_JOIN kind. We use the planner's flatten_join_alias_vars
1113  * routine to do the flattening; it wants a PlannerInfo root node, which
1114  * fortunately can be mostly dummy.
1115  */
1116  if (hasJoinRTEs)
1117  {
1118  root = makeNode(PlannerInfo);
1119  root->parse = qry;
1121  root->hasJoinRTEs = true;
1122 
1123  groupClauses = (List *) flatten_join_alias_vars(root,
1124  (Node *) groupClauses);
1125  }
1126 
1127  /*
1128  * Detect whether any of the grouping expressions aren't simple Vars; if
1129  * they're all Vars then we don't have to work so hard in the recursive
1130  * scans. (Note we have to flatten aliases before this.)
1131  *
1132  * Track Vars that are included in all grouping sets separately in
1133  * groupClauseCommonVars, since these are the only ones we can use to
1134  * check for functional dependencies.
1135  */
1136  have_non_var_grouping = false;
1137  foreach(l, groupClauses)
1138  {
1139  TargetEntry *tle = lfirst(l);
1140 
1141  if (!IsA(tle->expr, Var))
1142  {
1143  have_non_var_grouping = true;
1144  }
1145  else if (!qry->groupingSets ||
1146  list_member_int(gset_common, tle->ressortgroupref))
1147  {
1148  groupClauseCommonVars = lappend(groupClauseCommonVars, tle->expr);
1149  }
1150  }
1151 
1152  /*
1153  * Check the targetlist and HAVING clause for ungrouped variables.
1154  *
1155  * Note: because we check resjunk tlist elements as well as regular ones,
1156  * this will also find ungrouped variables that came from ORDER BY and
1157  * WINDOW clauses. For that matter, it's also going to examine the
1158  * grouping expressions themselves --- but they'll all pass the test ...
1159  *
1160  * We also finalize GROUPING expressions, but for that we need to traverse
1161  * the original (unflattened) clause in order to modify nodes.
1162  */
1163  clause = (Node *) qry->targetList;
1164  finalize_grouping_exprs(clause, pstate, qry,
1165  groupClauses, root,
1166  have_non_var_grouping);
1167  if (hasJoinRTEs)
1168  clause = flatten_join_alias_vars(root, clause);
1169  check_ungrouped_columns(clause, pstate, qry,
1170  groupClauses, groupClauseCommonVars,
1171  have_non_var_grouping,
1172  &func_grouped_rels);
1173 
1174  clause = (Node *) qry->havingQual;
1175  finalize_grouping_exprs(clause, pstate, qry,
1176  groupClauses, root,
1177  have_non_var_grouping);
1178  if (hasJoinRTEs)
1179  clause = flatten_join_alias_vars(root, clause);
1180  check_ungrouped_columns(clause, pstate, qry,
1181  groupClauses, groupClauseCommonVars,
1182  have_non_var_grouping,
1183  &func_grouped_rels);
1184 
1185  /*
1186  * Per spec, aggregates can't appear in a recursive term.
1187  */
1188  if (pstate->p_hasAggs && hasSelfRefRTEs)
1189  ereport(ERROR,
1190  (errcode(ERRCODE_INVALID_RECURSION),
1191  errmsg("aggregate functions are not allowed in a recursive query's recursive term"),
1192  parser_errposition(pstate,
1193  locate_agg_of_level((Node *) qry, 0))));
1194 }
#define NIL
Definition: pg_list.h:69
#define IsA(nodeptr, _type_)
Definition: nodes.h:568
Query * parse
Definition: relation.h:169
TargetEntry * get_sortgroupclause_tle(SortGroupClause *sgClause, List *targetList)
Definition: tlist.c:370
bool hasJoinRTEs
Definition: relation.h:315
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1186
List * list_intersection_int(const List *list1, const List *list2)
Definition: list.c:826
List * groupingSets
Definition: parsenodes.h:150
Definition: nodes.h:517
int errcode(int sqlerrcode)
Definition: elog.c:575
bool p_hasAggs
Definition: parse_node.h:200
Definition: primnodes.h:164
List * targetList
Definition: parsenodes.h:140
static void check_ungrouped_columns(Node *node, ParseState *pstate, Query *qry, List *groupClauses, List *groupClauseVars, bool have_non_var_grouping, List **func_grouped_rels)
Definition: parse_agg.c:1218
#define linitial(l)
Definition: pg_list.h:111
#define ERROR
Definition: elog.h:43
static void finalize_grouping_exprs(Node *node, ParseState *pstate, Query *qry, List *groupClauses, PlannerInfo *root, bool have_non_var_grouping)
Definition: parse_agg.c:1426
bool list_member_int(const List *list, int datum)
Definition: list.c:485
static ListCell * list_head(const List *l)
Definition: pg_list.h:77
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
#define lnext(lc)
Definition: pg_list.h:105
#define ereport(elevel, rest)
Definition: elog.h:122
List * lappend(List *list, void *datum)
Definition: list.c:128
int locate_agg_of_level(Node *node, int levelsup)
Definition: rewriteManip.c:131
Node * flatten_join_alias_vars(PlannerInfo *root, Node *node)
Definition: var.c:670
bool self_reference
Definition: parsenodes.h:1034
List * lcons(void *datum, List *list)
Definition: list.c:259
#define makeNode(_type_)
Definition: nodes.h:565
#define Assert(condition)
Definition: c.h:699
#define lfirst(lc)
Definition: pg_list.h:106
Expr * expr
Definition: primnodes.h:1376
static int list_length(const List *l)
Definition: pg_list.h:89
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
#define for_each_cell(cell, initcell)
Definition: pg_list.h:169
List * expand_grouping_sets(List *groupingSets, int limit)
Definition: parse_agg.c:1721
RTEKind rtekind
Definition: parsenodes.h:962
List * groupClause
Definition: parsenodes.h:148
int errmsg(const char *fmt,...)
Definition: elog.c:797
Index ressortgroupref
Definition: primnodes.h:1379
MemoryContext planner_cxt
Definition: relation.h:302
Node * havingQual
Definition: parsenodes.h:152
Definition: pg_list.h:45
List * p_rtable
Definition: parse_node.h:174

◆ resolve_aggregate_transtype()

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

Definition at line 1846 of file parse_agg.c.

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

Referenced by get_agg_clause_costs_walker(), and initialize_peragg().

1850 {
1851  /* resolve actual type of transition state, if polymorphic */
1852  if (IsPolymorphicType(aggtranstype))
1853  {
1854  /* have to fetch the agg's declared input types... */
1855  Oid *declaredArgTypes;
1856  int agg_nargs;
1857 
1858  (void) get_func_signature(aggfuncid, &declaredArgTypes, &agg_nargs);
1859 
1860  /*
1861  * VARIADIC ANY aggs could have more actual than declared args, but
1862  * such extra args can't affect polymorphic type resolution.
1863  */
1864  Assert(agg_nargs <= numArguments);
1865 
1866  aggtranstype = enforce_generic_type_consistency(inputTypes,
1867  declaredArgTypes,
1868  agg_nargs,
1869  aggtranstype,
1870  false);
1871  pfree(declaredArgTypes);
1872  }
1873  return aggtranstype;
1874 }
Oid get_func_signature(Oid funcid, Oid **argtypes, int *nargs)
Definition: lsyscache.c:1485
unsigned int Oid
Definition: postgres_ext.h:31
void pfree(void *pointer)
Definition: mcxt.c:1031
Oid enforce_generic_type_consistency(Oid *actual_arg_types, Oid *declared_arg_types, int nargs, Oid rettype, bool allow_poly)
#define Assert(condition)
Definition: c.h:699

◆ transformAggregateCall()

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

Definition at line 103 of file parse_agg.c.

References addTargetToSortList(), Aggref::aggargtypes, Aggref::aggdirectargs, Aggref::aggdistinct, Aggref::aggkind, Aggref::aggorder, arg, Aggref::args, Assert, check_agglevels_and_constraints(), ereport, errcode(), errdetail(), errmsg(), ERROR, 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().

105 {
106  List *argtypes = NIL;
107  List *tlist = NIL;
108  List *torder = NIL;
109  List *tdistinct = NIL;
110  AttrNumber attno = 1;
111  int save_next_resno;
112  ListCell *lc;
113 
114  /*
115  * Before separating the args into direct and aggregated args, make a list
116  * of their data type OIDs for use later.
117  */
118  foreach(lc, args)
119  {
120  Expr *arg = (Expr *) lfirst(lc);
121 
122  argtypes = lappend_oid(argtypes, exprType((Node *) arg));
123  }
124  agg->aggargtypes = argtypes;
125 
126  if (AGGKIND_IS_ORDERED_SET(agg->aggkind))
127  {
128  /*
129  * For an ordered-set agg, the args list includes direct args and
130  * aggregated args; we must split them apart.
131  */
132  int numDirectArgs = list_length(args) - list_length(aggorder);
133  List *aargs;
134  ListCell *lc2;
135 
136  Assert(numDirectArgs >= 0);
137 
138  aargs = list_copy_tail(args, numDirectArgs);
139  agg->aggdirectargs = list_truncate(args, numDirectArgs);
140 
141  /*
142  * Build a tlist from the aggregated args, and make a sortlist entry
143  * for each one. Note that the expressions in the SortBy nodes are
144  * ignored (they are the raw versions of the transformed args); we are
145  * just looking at the sort information in the SortBy nodes.
146  */
147  forboth(lc, aargs, lc2, aggorder)
148  {
149  Expr *arg = (Expr *) lfirst(lc);
150  SortBy *sortby = (SortBy *) lfirst(lc2);
151  TargetEntry *tle;
152 
153  /* We don't bother to assign column names to the entries */
154  tle = makeTargetEntry(arg, attno++, NULL, false);
155  tlist = lappend(tlist, tle);
156 
157  torder = addTargetToSortList(pstate, tle,
158  torder, tlist, sortby);
159  }
160 
161  /* Never any DISTINCT in an ordered-set agg */
162  Assert(!agg_distinct);
163  }
164  else
165  {
166  /* Regular aggregate, so it has no direct args */
167  agg->aggdirectargs = NIL;
168 
169  /*
170  * Transform the plain list of Exprs into a targetlist.
171  */
172  foreach(lc, args)
173  {
174  Expr *arg = (Expr *) lfirst(lc);
175  TargetEntry *tle;
176 
177  /* We don't bother to assign column names to the entries */
178  tle = makeTargetEntry(arg, attno++, NULL, false);
179  tlist = lappend(tlist, tle);
180  }
181 
182  /*
183  * If we have an ORDER BY, transform it. This will add columns to the
184  * tlist if they appear in ORDER BY but weren't already in the arg
185  * list. They will be marked resjunk = true so we can tell them apart
186  * from regular aggregate arguments later.
187  *
188  * We need to mess with p_next_resno since it will be used to number
189  * any new targetlist entries.
190  */
191  save_next_resno = pstate->p_next_resno;
192  pstate->p_next_resno = attno;
193 
194  torder = transformSortClause(pstate,
195  aggorder,
196  &tlist,
198  true /* force SQL99 rules */ );
199 
200  /*
201  * If we have DISTINCT, transform that to produce a distinctList.
202  */
203  if (agg_distinct)
204  {
205  tdistinct = transformDistinctClause(pstate, &tlist, torder, true);
206 
207  /*
208  * Remove this check if executor support for hashed distinct for
209  * aggregates is ever added.
210  */
211  foreach(lc, tdistinct)
212  {
213  SortGroupClause *sortcl = (SortGroupClause *) lfirst(lc);
214 
215  if (!OidIsValid(sortcl->sortop))
216  {
217  Node *expr = get_sortgroupclause_expr(sortcl, tlist);
218 
219  ereport(ERROR,
220  (errcode(ERRCODE_UNDEFINED_FUNCTION),
221  errmsg("could not identify an ordering operator for type %s",
222  format_type_be(exprType(expr))),
223  errdetail("Aggregates with DISTINCT must be able to sort their inputs."),
224  parser_errposition(pstate, exprLocation(expr))));
225  }
226  }
227  }
228 
229  pstate->p_next_resno = save_next_resno;
230  }
231 
232  /* Update the Aggref with the transformation results */
233  agg->args = tlist;
234  agg->aggorder = torder;
235  agg->aggdistinct = tdistinct;
236 
237  check_agglevels_and_constraints(pstate, (Node *) agg);
238 }
List * aggdistinct
Definition: primnodes.h:304
#define NIL
Definition: pg_list.h:69
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:180
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1186
List * addTargetToSortList(ParseState *pstate, TargetEntry *tle, List *sortlist, List *targetlist, SortBy *sortby)
List * transformSortClause(ParseState *pstate, List *orderlist, List **targetlist, ParseExprKind exprKind, bool useSQL99)
List * list_truncate(List *list, int new_size)
Definition: list.c:350
Node * get_sortgroupclause_expr(SortGroupClause *sgClause, List *targetList)
Definition: tlist.c:382
Definition: nodes.h:517
int errcode(int sqlerrcode)
Definition: elog.c:575
List * args
Definition: primnodes.h:302
char * format_type_be(Oid type_oid)
Definition: format_type.c:328
static void check_agglevels_and_constraints(ParseState *pstate, Node *expr)
Definition: parse_agg.c:287
List * list_copy_tail(const List *oldlist, int nskip)
Definition: list.c:1203
List * lappend_oid(List *list, Oid datum)
Definition: list.c:164
#define OidIsValid(objectId)
Definition: c.h:605
List * aggargtypes
Definition: primnodes.h:300
#define ERROR
Definition: elog.h:43
List * aggorder
Definition: primnodes.h:303
int errdetail(const char *fmt,...)
Definition: elog.c:873
int p_next_resno
Definition: parse_node.h:189
List * aggdirectargs
Definition: primnodes.h:301
#define ereport(elevel, rest)
Definition: elog.h:122
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition: makefuncs.c:237
List * lappend(List *list, void *datum)
Definition: list.c:128
#define Assert(condition)
Definition: c.h:699
#define lfirst(lc)
Definition: pg_list.h:106
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
static int list_length(const List *l)
Definition: pg_list.h:89
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
int errmsg(const char *fmt,...)
Definition: elog.c:797
void * arg
char aggkind
Definition: primnodes.h:309
List * transformDistinctClause(ParseState *pstate, List **targetlist, List *sortClause, bool is_agg)
Definition: pg_list.h:45
int16 AttrNumber
Definition: attnum.h:21

◆ transformGroupingFunc()

Node* transformGroupingFunc ( ParseState pstate,
GroupingFunc g 
)

Definition at line 248 of file parse_agg.c.

References generate_unaccent_rules::args, GroupingFunc::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().

249 {
250  ListCell *lc;
251  List *args = p->args;
252  List *result_list = NIL;
254 
255  if (list_length(args) > 31)
256  ereport(ERROR,
257  (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
258  errmsg("GROUPING must have fewer than 32 arguments"),
259  parser_errposition(pstate, p->location)));
260 
261  foreach(lc, args)
262  {
263  Node *current_result;
264 
265  current_result = transformExpr(pstate, (Node *) lfirst(lc), pstate->p_expr_kind);
266 
267  /* acceptability of expressions is checked later */
268 
269  result_list = lappend(result_list, current_result);
270  }
271 
272  result->args = result_list;
273  result->location = p->location;
274 
275  check_agglevels_and_constraints(pstate, (Node *) result);
276 
277  return (Node *) result;
278 }
#define NIL
Definition: pg_list.h:69
List * args
Definition: primnodes.h:342
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:146
Definition: nodes.h:517
int errcode(int sqlerrcode)
Definition: elog.c:575
static void check_agglevels_and_constraints(ParseState *pstate, Node *expr)
Definition: parse_agg.c:287
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
List * lappend(List *list, void *datum)
Definition: list.c:128
ParseExprKind p_expr_kind
Definition: parse_node.h:188
#define makeNode(_type_)
Definition: nodes.h:565
#define lfirst(lc)
Definition: pg_list.h:106
static int list_length(const List *l)
Definition: pg_list.h:89
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
int errmsg(const char *fmt,...)
Definition: elog.c:797
Definition: pg_list.h:45

◆ transformWindowFuncCall()

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

Definition at line 776 of file parse_agg.c.

References _, WindowFunc::args, Assert, contain_windowfuncs(), WindowDef::endOffset, equal(), ereport, errcode(), errmsg(), errmsg_internal(), ERROR, EXPR_KIND_ALTER_COL_TRANSFORM, EXPR_KIND_CALL_ARGUMENT, EXPR_KIND_CHECK_CONSTRAINT, EXPR_KIND_COLUMN_DEFAULT, 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_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_NONE, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, EXPR_KIND_OTHER, EXPR_KIND_PARTITION_EXPRESSION, EXPR_KIND_POLICY, EXPR_KIND_RETURNING, EXPR_KIND_SELECT_TARGET, 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(), WindowFunc::location, WindowDef::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().

778 {
779  const char *err;
780  bool errkind;
781 
782  /*
783  * A window function call can't contain another one (but aggs are OK). XXX
784  * is this required by spec, or just an unimplemented feature?
785  *
786  * Note: we don't need to check the filter expression here, because the
787  * context checks done below and in transformAggregateCall would have
788  * already rejected any window funcs or aggs within the filter.
789  */
790  if (pstate->p_hasWindowFuncs &&
791  contain_windowfuncs((Node *) wfunc->args))
792  ereport(ERROR,
793  (errcode(ERRCODE_WINDOWING_ERROR),
794  errmsg("window function calls cannot be nested"),
795  parser_errposition(pstate,
796  locate_windowfunc((Node *) wfunc->args))));
797 
798  /*
799  * Check to see if the window function is in an invalid place within the
800  * query.
801  *
802  * For brevity we support two schemes for reporting an error here: set
803  * "err" to a custom message, or set "errkind" true if the error context
804  * is sufficiently identified by what ParseExprKindName will return, *and*
805  * what it will return is just a SQL keyword. (Otherwise, use a custom
806  * message to avoid creating translation problems.)
807  */
808  err = NULL;
809  errkind = false;
810  switch (pstate->p_expr_kind)
811  {
812  case EXPR_KIND_NONE:
813  Assert(false); /* can't happen */
814  break;
815  case EXPR_KIND_OTHER:
816  /* Accept window func here; caller must throw error if wanted */
817  break;
818  case EXPR_KIND_JOIN_ON:
820  err = _("window functions are not allowed in JOIN conditions");
821  break;
823  /* can't get here, but just in case, throw an error */
824  errkind = true;
825  break;
827  err = _("window functions are not allowed in functions in FROM");
828  break;
829  case EXPR_KIND_WHERE:
830  errkind = true;
831  break;
832  case EXPR_KIND_POLICY:
833  err = _("window functions are not allowed in policy expressions");
834  break;
835  case EXPR_KIND_HAVING:
836  errkind = true;
837  break;
838  case EXPR_KIND_FILTER:
839  errkind = true;
840  break;
846  err = _("window functions are not allowed in window definitions");
847  break;
849  /* okay */
850  break;
854  errkind = true;
855  break;
856  case EXPR_KIND_GROUP_BY:
857  errkind = true;
858  break;
859  case EXPR_KIND_ORDER_BY:
860  /* okay */
861  break;
863  /* okay */
864  break;
865  case EXPR_KIND_LIMIT:
866  case EXPR_KIND_OFFSET:
867  errkind = true;
868  break;
869  case EXPR_KIND_RETURNING:
870  errkind = true;
871  break;
872  case EXPR_KIND_VALUES:
874  errkind = true;
875  break;
878  err = _("window functions are not allowed in check constraints");
879  break;
882  err = _("window functions are not allowed in DEFAULT expressions");
883  break;
885  err = _("window functions are not allowed in index expressions");
886  break;
888  err = _("window functions are not allowed in index predicates");
889  break;
891  err = _("window functions are not allowed in transform expressions");
892  break;
894  err = _("window functions are not allowed in EXECUTE parameters");
895  break;
897  err = _("window functions are not allowed in trigger WHEN conditions");
898  break;
900  err = _("window functions are not allowed in partition key expressions");
901  break;
903  err = _("window functions are not allowed in CALL arguments");
904  break;
905 
906  /*
907  * There is intentionally no default: case here, so that the
908  * compiler will warn if we add a new ParseExprKind without
909  * extending this switch. If we do see an unrecognized value at
910  * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
911  * which is sane anyway.
912  */
913  }
914  if (err)
915  ereport(ERROR,
916  (errcode(ERRCODE_WINDOWING_ERROR),
917  errmsg_internal("%s", err),
918  parser_errposition(pstate, wfunc->location)));
919  if (errkind)
920  ereport(ERROR,
921  (errcode(ERRCODE_WINDOWING_ERROR),
922  /* translator: %s is name of a SQL construct, eg GROUP BY */
923  errmsg("window functions are not allowed in %s",
924  ParseExprKindName(pstate->p_expr_kind)),
925  parser_errposition(pstate, wfunc->location)));
926 
927  /*
928  * If the OVER clause just specifies a window name, find that WINDOW
929  * clause (which had better be present). Otherwise, try to match all the
930  * properties of the OVER clause, and make a new entry in the p_windowdefs
931  * list if no luck.
932  */
933  if (windef->name)
934  {
935  Index winref = 0;
936  ListCell *lc;
937 
938  Assert(windef->refname == NULL &&
939  windef->partitionClause == NIL &&
940  windef->orderClause == NIL &&
942 
943  foreach(lc, pstate->p_windowdefs)
944  {
945  WindowDef *refwin = (WindowDef *) lfirst(lc);
946 
947  winref++;
948  if (refwin->name && strcmp(refwin->name, windef->name) == 0)
949  {
950  wfunc->winref = winref;
951  break;
952  }
953  }
954  if (lc == NULL) /* didn't find it? */
955  ereport(ERROR,
956  (errcode(ERRCODE_UNDEFINED_OBJECT),
957  errmsg("window \"%s\" does not exist", windef->name),
958  parser_errposition(pstate, windef->location)));
959  }
960  else
961  {
962  Index winref = 0;
963  ListCell *lc;
964 
965  foreach(lc, pstate->p_windowdefs)
966  {
967  WindowDef *refwin = (WindowDef *) lfirst(lc);
968 
969  winref++;
970  if (refwin->refname && windef->refname &&
971  strcmp(refwin->refname, windef->refname) == 0)
972  /* matched on refname */ ;
973  else if (!refwin->refname && !windef->refname)
974  /* matched, no refname */ ;
975  else
976  continue;
977  if (equal(refwin->partitionClause, windef->partitionClause) &&
978  equal(refwin->orderClause, windef->orderClause) &&
979  refwin->frameOptions == windef->frameOptions &&
980  equal(refwin->startOffset, windef->startOffset) &&
981  equal(refwin->endOffset, windef->endOffset))
982  {
983  /* found a duplicate window specification */
984  wfunc->winref = winref;
985  break;
986  }
987  }
988  if (lc == NULL) /* didn't find it? */
989  {
990  pstate->p_windowdefs = lappend(pstate->p_windowdefs, windef);
991  wfunc->winref = list_length(pstate->p_windowdefs);
992  }
993  }
994 
995  pstate->p_hasWindowFuncs = true;
996 }
List * partitionClause
Definition: parsenodes.h:490
#define NIL
Definition: pg_list.h:69
#define FRAMEOPTION_DEFAULTS
Definition: parsenodes.h:532
List * args
Definition: primnodes.h:360
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:2986
int frameOptions
Definition: parsenodes.h:492
char * name
Definition: parsenodes.h:488
Definition: nodes.h:517
int errcode(int sqlerrcode)
Definition: elog.c:575
int locate_windowfunc(Node *node)
Definition: rewriteManip.c:235
Index winref
Definition: primnodes.h:362
const char * ParseExprKindName(ParseExprKind exprKind)
Definition: parse_expr.c:3402
bool p_hasWindowFuncs
Definition: parse_node.h:201
Node * startOffset
Definition: parsenodes.h:493
#define ERROR
Definition: elog.h:43
int location
Definition: parsenodes.h:495
List * p_windowdefs
Definition: parse_node.h:187
Node * endOffset
Definition: parsenodes.h:494
#define ereport(elevel, rest)
Definition: elog.h:122
List * lappend(List *list, void *datum)
Definition: list.c:128
List * orderClause
Definition: parsenodes.h:491
unsigned int Index
Definition: c.h:442
ParseExprKind p_expr_kind
Definition: parse_node.h:188
int errmsg_internal(const char *fmt,...)
Definition: elog.c:827
int location
Definition: primnodes.h:365
#define Assert(condition)
Definition: c.h:699
#define lfirst(lc)
Definition: pg_list.h:106
static int list_length(const List *l)
Definition: pg_list.h:89
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
int errmsg(const char *fmt,...)
Definition: elog.c:797
char * refname
Definition: parsenodes.h:489
#define _(x)
Definition: elog.c:84
bool contain_windowfuncs(Node *node)
Definition: rewriteManip.c:197