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, bool groupDistinct, 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 2028 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().

2032 {
2033  Node *argp;
2034  List *args;
2035  FuncExpr *fexpr;
2036 
2037  /* combinefn takes two arguments of the aggregate state type */
2038  argp = make_agg_arg(agg_state_type, agg_input_collation);
2039 
2040  args = list_make2(argp, argp);
2041 
2042  fexpr = makeFuncExpr(combinefn_oid,
2043  agg_state_type,
2044  args,
2045  InvalidOid,
2046  agg_input_collation,
2048  /* combinefn is currently never treated as variadic */
2049  *combinefnexpr = (Expr *) fexpr;
2050 }
#define list_make2(x1, x2)
Definition: pg_list.h:208
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2144
Definition: nodes.h:539
#define InvalidOid
Definition: postgres_ext.h:36
Definition: pg_list.h:50
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 2080 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().

2082 {
2083  List *args;
2084  FuncExpr *fexpr;
2085 
2086  /* deserialfn always takes BYTEA, INTERNAL and returns INTERNAL */
2087  args = list_make2(make_agg_arg(BYTEAOID, InvalidOid),
2088  make_agg_arg(INTERNALOID, InvalidOid));
2089 
2090  fexpr = makeFuncExpr(deserialfn_oid,
2091  INTERNALOID,
2092  args,
2093  InvalidOid,
2094  InvalidOid,
2096  *deserialfnexpr = (Expr *) fexpr;
2097 }
#define list_make2(x1, x2)
Definition: pg_list.h:208
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2144
#define InvalidOid
Definition: postgres_ext.h:36
Definition: pg_list.h:50
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 2104 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().

2111 {
2112  List *args;
2113  int i;
2114 
2115  /*
2116  * Build expr tree for final function
2117  */
2118  args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
2119 
2120  /* finalfn may take additional args, which match agg's input types */
2121  for (i = 0; i < num_finalfn_inputs - 1; i++)
2122  {
2123  args = lappend(args,
2124  make_agg_arg(agg_input_types[i], agg_input_collation));
2125  }
2126 
2127  *finalfnexpr = (Expr *) makeFuncExpr(finalfn_oid,
2128  agg_result_type,
2129  args,
2130  InvalidOid,
2131  agg_input_collation,
2133  /* finalfn is currently never treated as variadic */
2134 }
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2144
#define list_make1(x1)
Definition: pg_list.h:206
List * lappend(List *list, void *datum)
Definition: list.c:336
#define InvalidOid
Definition: postgres_ext.h:36
int i
Definition: pg_list.h:50
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 2057 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().

2059 {
2060  List *args;
2061  FuncExpr *fexpr;
2062 
2063  /* serialfn always takes INTERNAL and returns BYTEA */
2064  args = list_make1(make_agg_arg(INTERNALOID, InvalidOid));
2065 
2066  fexpr = makeFuncExpr(serialfn_oid,
2067  BYTEAOID,
2068  args,
2069  InvalidOid,
2070  InvalidOid,
2072  *serialfnexpr = (Expr *) fexpr;
2073 }
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2144
#define list_make1(x1)
Definition: pg_list.h:206
#define InvalidOid
Definition: postgres_ext.h:36
Definition: pg_list.h:50
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 1967 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().

1977 {
1978  List *args;
1979  FuncExpr *fexpr;
1980  int i;
1981 
1982  /*
1983  * Build arg list to use in the transfn FuncExpr node.
1984  */
1985  args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
1986 
1987  for (i = agg_num_direct_inputs; i < agg_num_inputs; i++)
1988  {
1989  args = lappend(args,
1990  make_agg_arg(agg_input_types[i], agg_input_collation));
1991  }
1992 
1993  fexpr = makeFuncExpr(transfn_oid,
1994  agg_state_type,
1995  args,
1996  InvalidOid,
1997  agg_input_collation,
1999  fexpr->funcvariadic = agg_variadic;
2000  *transfnexpr = (Expr *) fexpr;
2001 
2002  /*
2003  * Build invtransfn expression if requested, with same args as transfn
2004  */
2005  if (invtransfnexpr != NULL)
2006  {
2007  if (OidIsValid(invtransfn_oid))
2008  {
2009  fexpr = makeFuncExpr(invtransfn_oid,
2010  agg_state_type,
2011  args,
2012  InvalidOid,
2013  agg_input_collation,
2015  fexpr->funcvariadic = agg_variadic;
2016  *invtransfnexpr = (Expr *) fexpr;
2017  }
2018  else
2019  *invtransfnexpr = NULL;
2020  }
2021 }
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2144
#define OidIsValid(objectId)
Definition: c.h:710
#define list_make1(x1)
Definition: pg_list.h:206
List * lappend(List *list, void *datum)
Definition: list.c:336
#define InvalidOid
Definition: postgres_ext.h:36
int i
Definition: pg_list.h:50
bool funcvariadic
Definition: primnodes.h:498
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,
bool  groupDistinct,
int  limit 
)

Definition at line 1783 of file parse_agg.c.

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

Referenced by parseCheckAggregates(), and preprocess_grouping_sets().

1784 {
1785  List *expanded_groups = NIL;
1786  List *result = NIL;
1787  double numsets = 1;
1788  ListCell *lc;
1789 
1790  if (groupingSets == NIL)
1791  return NIL;
1792 
1793  foreach(lc, groupingSets)
1794  {
1795  List *current_result = NIL;
1796  GroupingSet *gs = lfirst(lc);
1797 
1798  current_result = expand_groupingset_node(gs);
1799 
1800  Assert(current_result != NIL);
1801 
1802  numsets *= list_length(current_result);
1803 
1804  if (limit >= 0 && numsets > limit)
1805  return NIL;
1806 
1807  expanded_groups = lappend(expanded_groups, current_result);
1808  }
1809 
1810  /*
1811  * Do cartesian product between sublists of expanded_groups. While at it,
1812  * remove any duplicate elements from individual grouping sets (we must
1813  * NOT change the number of sets though)
1814  */
1815 
1816  foreach(lc, (List *) linitial(expanded_groups))
1817  {
1818  result = lappend(result, list_union_int(NIL, (List *) lfirst(lc)));
1819  }
1820 
1821  for_each_from(lc, expanded_groups, 1)
1822  {
1823  List *p = lfirst(lc);
1824  List *new_result = NIL;
1825  ListCell *lc2;
1826 
1827  foreach(lc2, result)
1828  {
1829  List *q = lfirst(lc2);
1830  ListCell *lc3;
1831 
1832  foreach(lc3, p)
1833  {
1834  new_result = lappend(new_result,
1835  list_union_int(q, (List *) lfirst(lc3)));
1836  }
1837  }
1838  result = new_result;
1839  }
1840 
1841  /* Now sort the lists by length and deduplicate if necessary */
1842  if (!groupDistinct || list_length(result) < 2)
1843  list_sort(result, cmp_list_len_asc);
1844  else
1845  {
1846  ListCell *cell;
1847  List *prev;
1848 
1849  /* Sort each groupset individually */
1850  foreach(cell, result)
1851  list_sort(lfirst(cell), list_int_cmp);
1852 
1853  /* Now sort the list of groupsets by length and contents */
1855 
1856  /* Finally, remove duplicates */
1857  prev = linitial_node(List, result);
1858  for_each_from(cell, result, 1)
1859  {
1860  if (equal(lfirst(cell), prev))
1861  result = foreach_delete_current(result, cell);
1862  else
1863  prev = lfirst(cell);
1864  }
1865  }
1866 
1867  return result;
1868 }
#define NIL
Definition: pg_list.h:65
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:3105
#define linitial_node(type, l)
Definition: pg_list.h:177
#define foreach_delete_current(lst, cell)
Definition: pg_list.h:369
#define linitial(l)
Definition: pg_list.h:174
static List * expand_groupingset_node(GroupingSet *gs)
Definition: parse_agg.c:1638
List * list_union_int(const List *list1, const List *list2)
Definition: list.c:977
List * lappend(List *list, void *datum)
Definition: list.c:336
#define Assert(condition)
Definition: c.h:804
#define lfirst(lc)
Definition: pg_list.h:169
static int list_length(const List *l)
Definition: pg_list.h:149
#define for_each_from(cell, lst, N)
Definition: pg_list.h:393
static int cmp_list_len_contents_asc(const ListCell *a, const ListCell *b)
Definition: parse_agg.c:1750
static int cmp_list_len_asc(const ListCell *a, const ListCell *b)
Definition: parse_agg.c:1740
void list_sort(List *list, list_sort_comparator cmp)
Definition: list.c:1496
int list_int_cmp(const ListCell *p1, const ListCell *p2)
Definition: list.c:1513
Definition: pg_list.h:50

◆ get_aggregate_argtypes()

int get_aggregate_argtypes ( Aggref aggref,
Oid inputTypes 
)

Definition at line 1886 of file parse_agg.c.

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

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

1887 {
1888  int numArguments = 0;
1889  ListCell *lc;
1890 
1892 
1893  foreach(lc, aggref->aggargtypes)
1894  {
1895  inputTypes[numArguments++] = lfirst_oid(lc);
1896  }
1897 
1898  return numArguments;
1899 }
#define FUNC_MAX_ARGS
List * aggargtypes
Definition: primnodes.h:328
#define Assert(condition)
Definition: c.h:804
static int list_length(const List *l)
Definition: pg_list.h:149
#define lfirst_oid(lc)
Definition: pg_list.h:171

◆ parseCheckAggregates()

void parseCheckAggregates ( ParseState pstate,
Query qry 
)

Definition at line 1059 of file parse_agg.c.

References Assert, check_ungrouped_columns(), 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_hasAggs, ParseState::p_rtable, parser_errposition(), TargetEntry::ressortgroupref, RTE_CTE, RTE_JOIN, RangeTblEntry::rtekind, RangeTblEntry::self_reference, and Query::targetList.

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

1060 {
1061  List *gset_common = NIL;
1062  List *groupClauses = NIL;
1063  List *groupClauseCommonVars = NIL;
1064  bool have_non_var_grouping;
1065  List *func_grouped_rels = NIL;
1066  ListCell *l;
1067  bool hasJoinRTEs;
1068  bool hasSelfRefRTEs;
1069  Node *clause;
1070 
1071  /* This should only be called if we found aggregates or grouping */
1072  Assert(pstate->p_hasAggs || qry->groupClause || qry->havingQual || qry->groupingSets);
1073 
1074  /*
1075  * If we have grouping sets, expand them and find the intersection of all
1076  * sets.
1077  */
1078  if (qry->groupingSets)
1079  {
1080  /*
1081  * The limit of 4096 is arbitrary and exists simply to avoid resource
1082  * issues from pathological constructs.
1083  */
1084  List *gsets = expand_grouping_sets(qry->groupingSets, qry->groupDistinct, 4096);
1085 
1086  if (!gsets)
1087  ereport(ERROR,
1088  (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
1089  errmsg("too many grouping sets present (maximum 4096)"),
1090  parser_errposition(pstate,
1091  qry->groupClause
1092  ? exprLocation((Node *) qry->groupClause)
1093  : exprLocation((Node *) qry->groupingSets))));
1094 
1095  /*
1096  * The intersection will often be empty, so help things along by
1097  * seeding the intersect with the smallest set.
1098  */
1099  gset_common = linitial(gsets);
1100 
1101  if (gset_common)
1102  {
1103  for_each_from(l, gsets, 1)
1104  {
1105  gset_common = list_intersection_int(gset_common, lfirst(l));
1106  if (!gset_common)
1107  break;
1108  }
1109  }
1110 
1111  /*
1112  * If there was only one grouping set in the expansion, AND if the
1113  * groupClause is non-empty (meaning that the grouping set is not
1114  * empty either), then we can ditch the grouping set and pretend we
1115  * just had a normal GROUP BY.
1116  */
1117  if (list_length(gsets) == 1 && qry->groupClause)
1118  qry->groupingSets = NIL;
1119  }
1120 
1121  /*
1122  * Scan the range table to see if there are JOIN or self-reference CTE
1123  * entries. We'll need this info below.
1124  */
1125  hasJoinRTEs = hasSelfRefRTEs = false;
1126  foreach(l, pstate->p_rtable)
1127  {
1128  RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
1129 
1130  if (rte->rtekind == RTE_JOIN)
1131  hasJoinRTEs = true;
1132  else if (rte->rtekind == RTE_CTE && rte->self_reference)
1133  hasSelfRefRTEs = true;
1134  }
1135 
1136  /*
1137  * Build a list of the acceptable GROUP BY expressions for use by
1138  * check_ungrouped_columns().
1139  *
1140  * We get the TLE, not just the expr, because GROUPING wants to know the
1141  * sortgroupref.
1142  */
1143  foreach(l, qry->groupClause)
1144  {
1145  SortGroupClause *grpcl = (SortGroupClause *) lfirst(l);
1146  TargetEntry *expr;
1147 
1148  expr = get_sortgroupclause_tle(grpcl, qry->targetList);
1149  if (expr == NULL)
1150  continue; /* probably cannot happen */
1151 
1152  groupClauses = lappend(groupClauses, expr);
1153  }
1154 
1155  /*
1156  * If there are join alias vars involved, we have to flatten them to the
1157  * underlying vars, so that aliased and unaliased vars will be correctly
1158  * taken as equal. We can skip the expense of doing this if no rangetable
1159  * entries are RTE_JOIN kind.
1160  */
1161  if (hasJoinRTEs)
1162  groupClauses = (List *) flatten_join_alias_vars(qry,
1163  (Node *) groupClauses);
1164 
1165  /*
1166  * Detect whether any of the grouping expressions aren't simple Vars; if
1167  * they're all Vars then we don't have to work so hard in the recursive
1168  * scans. (Note we have to flatten aliases before this.)
1169  *
1170  * Track Vars that are included in all grouping sets separately in
1171  * groupClauseCommonVars, since these are the only ones we can use to
1172  * check for functional dependencies.
1173  */
1174  have_non_var_grouping = false;
1175  foreach(l, groupClauses)
1176  {
1177  TargetEntry *tle = lfirst(l);
1178 
1179  if (!IsA(tle->expr, Var))
1180  {
1181  have_non_var_grouping = true;
1182  }
1183  else if (!qry->groupingSets ||
1184  list_member_int(gset_common, tle->ressortgroupref))
1185  {
1186  groupClauseCommonVars = lappend(groupClauseCommonVars, tle->expr);
1187  }
1188  }
1189 
1190  /*
1191  * Check the targetlist and HAVING clause for ungrouped variables.
1192  *
1193  * Note: because we check resjunk tlist elements as well as regular ones,
1194  * this will also find ungrouped variables that came from ORDER BY and
1195  * WINDOW clauses. For that matter, it's also going to examine the
1196  * grouping expressions themselves --- but they'll all pass the test ...
1197  *
1198  * We also finalize GROUPING expressions, but for that we need to traverse
1199  * the original (unflattened) clause in order to modify nodes.
1200  */
1201  clause = (Node *) qry->targetList;
1202  finalize_grouping_exprs(clause, pstate, qry,
1203  groupClauses, hasJoinRTEs,
1204  have_non_var_grouping);
1205  if (hasJoinRTEs)
1206  clause = flatten_join_alias_vars(qry, clause);
1207  check_ungrouped_columns(clause, pstate, qry,
1208  groupClauses, groupClauseCommonVars,
1209  have_non_var_grouping,
1210  &func_grouped_rels);
1211 
1212  clause = (Node *) qry->havingQual;
1213  finalize_grouping_exprs(clause, pstate, qry,
1214  groupClauses, hasJoinRTEs,
1215  have_non_var_grouping);
1216  if (hasJoinRTEs)
1217  clause = flatten_join_alias_vars(qry, clause);
1218  check_ungrouped_columns(clause, pstate, qry,
1219  groupClauses, groupClauseCommonVars,
1220  have_non_var_grouping,
1221  &func_grouped_rels);
1222 
1223  /*
1224  * Per spec, aggregates can't appear in a recursive term.
1225  */
1226  if (pstate->p_hasAggs && hasSelfRefRTEs)
1227  ereport(ERROR,
1228  (errcode(ERRCODE_INVALID_RECURSION),
1229  errmsg("aggregate functions are not allowed in a recursive query's recursive term"),
1230  parser_errposition(pstate,
1231  locate_agg_of_level((Node *) qry, 0))));
1232 }
#define NIL
Definition: pg_list.h:65
#define IsA(nodeptr, _type_)
Definition: nodes.h:590
TargetEntry * get_sortgroupclause_tle(SortGroupClause *sgClause, List *targetList)
Definition: tlist.c:356
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1250
List * list_intersection_int(const List *list1, const List *list2)
Definition: list.c:1059
bool groupDistinct
Definition: parsenodes.h:159
List * groupingSets
Definition: parsenodes.h:161
Definition: nodes.h:539
static void finalize_grouping_exprs(Node *node, ParseState *pstate, Query *qry, List *groupClauses, bool hasJoinRTEs, bool have_non_var_grouping)
Definition: parse_agg.c:1464
int errcode(int sqlerrcode)
Definition: elog.c:698
bool p_hasAggs
Definition: parse_node.h:208
Definition: primnodes.h:186
List * targetList
Definition: parsenodes.h:150
#define linitial(l)
Definition: pg_list.h:174
#define ERROR
Definition: elog.h:46
bool list_member_int(const List *list, int datum)
Definition: list.c:669
static void check_ungrouped_columns(Node *node, ParseState *pstate, Query *qry, List *groupClauses, List *groupClauseCommonVars, bool have_non_var_grouping, List **func_grouped_rels)
Definition: parse_agg.c:1256
List * lappend(List *list, void *datum)
Definition: list.c:336
int locate_agg_of_level(Node *node, int levelsup)
Definition: rewriteManip.c:131
bool self_reference
Definition: parsenodes.h:1107
Node * flatten_join_alias_vars(Query *query, Node *node)
Definition: var.c:697
#define ereport(elevel,...)
Definition: elog.h:157
List * expand_grouping_sets(List *groupingSets, bool groupDistinct, int limit)
Definition: parse_agg.c:1783
#define Assert(condition)
Definition: c.h:804
#define lfirst(lc)
Definition: pg_list.h:169
Expr * expr
Definition: primnodes.h:1444
static int list_length(const List *l)
Definition: pg_list.h:149
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
#define for_each_from(cell, lst, N)
Definition: pg_list.h:393
RTEKind rtekind
Definition: parsenodes.h:995
List * groupClause
Definition: parsenodes.h:158
int errmsg(const char *fmt,...)
Definition: elog.c:909
Index ressortgroupref
Definition: primnodes.h:1447
Node * havingQual
Definition: parsenodes.h:163
Definition: pg_list.h:50
List * p_rtable
Definition: parse_node.h:182

◆ resolve_aggregate_transtype()

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

Definition at line 1912 of file parse_agg.c.

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

Referenced by initialize_peragg(), and preprocess_aggref().

1916 {
1917  /* resolve actual type of transition state, if polymorphic */
1918  if (IsPolymorphicType(aggtranstype))
1919  {
1920  /* have to fetch the agg's declared input types... */
1921  Oid *declaredArgTypes;
1922  int agg_nargs;
1923 
1924  (void) get_func_signature(aggfuncid, &declaredArgTypes, &agg_nargs);
1925 
1926  /*
1927  * VARIADIC ANY aggs could have more actual than declared args, but
1928  * such extra args can't affect polymorphic type resolution.
1929  */
1930  Assert(agg_nargs <= numArguments);
1931 
1932  aggtranstype = enforce_generic_type_consistency(inputTypes,
1933  declaredArgTypes,
1934  agg_nargs,
1935  aggtranstype,
1936  false);
1937  pfree(declaredArgTypes);
1938  }
1939  return aggtranstype;
1940 }
Oid enforce_generic_type_consistency(const Oid *actual_arg_types, Oid *declared_arg_types, int nargs, Oid rettype, bool allow_poly)
Oid get_func_signature(Oid funcid, Oid **argtypes, int *nargs)
Definition: lsyscache.c:1667
unsigned int Oid
Definition: postgres_ext.h:31
void pfree(void *pointer)
Definition: mcxt.c:1169
#define Assert(condition)
Definition: c.h:804

◆ transformAggregateCall()

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

Definition at line 102 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().

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

◆ transformGroupingFunc()

Node* transformGroupingFunc ( ParseState pstate,
GroupingFunc g 
)

Definition at line 247 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().

248 {
249  ListCell *lc;
250  List *args = p->args;
251  List *result_list = NIL;
253 
254  if (list_length(args) > 31)
255  ereport(ERROR,
256  (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
257  errmsg("GROUPING must have fewer than 32 arguments"),
258  parser_errposition(pstate, p->location)));
259 
260  foreach(lc, args)
261  {
262  Node *current_result;
263 
264  current_result = transformExpr(pstate, (Node *) lfirst(lc), pstate->p_expr_kind);
265 
266  /* acceptability of expressions is checked later */
267 
268  result_list = lappend(result_list, current_result);
269  }
270 
271  result->args = result_list;
272  result->location = p->location;
273 
274  check_agglevels_and_constraints(pstate, (Node *) result);
275 
276  return (Node *) result;
277 }
#define NIL
Definition: pg_list.h:65
List * args
Definition: primnodes.h:372
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:94
Definition: nodes.h:539
int errcode(int sqlerrcode)
Definition: elog.c:698
static void check_agglevels_and_constraints(ParseState *pstate, Node *expr)
Definition: parse_agg.c:286
#define ERROR
Definition: elog.h:46
List * lappend(List *list, void *datum)
Definition: list.c:336
ParseExprKind p_expr_kind
Definition: parse_node.h:196
#define ereport(elevel,...)
Definition: elog.h:157
#define makeNode(_type_)
Definition: nodes.h:587
#define lfirst(lc)
Definition: pg_list.h:169
static int list_length(const List *l)
Definition: pg_list.h:149
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
int errmsg(const char *fmt,...)
Definition: elog.c:909
Definition: pg_list.h:50

◆ transformWindowFuncCall()

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

Definition at line 809 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_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_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(), 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().

811 {
812  const char *err;
813  bool errkind;
814 
815  /*
816  * A window function call can't contain another one (but aggs are OK). XXX
817  * is this required by spec, or just an unimplemented feature?
818  *
819  * Note: we don't need to check the filter expression here, because the
820  * context checks done below and in transformAggregateCall would have
821  * already rejected any window funcs or aggs within the filter.
822  */
823  if (pstate->p_hasWindowFuncs &&
824  contain_windowfuncs((Node *) wfunc->args))
825  ereport(ERROR,
826  (errcode(ERRCODE_WINDOWING_ERROR),
827  errmsg("window function calls cannot be nested"),
828  parser_errposition(pstate,
829  locate_windowfunc((Node *) wfunc->args))));
830 
831  /*
832  * Check to see if the window function is in an invalid place within the
833  * query.
834  *
835  * For brevity we support two schemes for reporting an error here: set
836  * "err" to a custom message, or set "errkind" true if the error context
837  * is sufficiently identified by what ParseExprKindName will return, *and*
838  * what it will return is just a SQL keyword. (Otherwise, use a custom
839  * message to avoid creating translation problems.)
840  */
841  err = NULL;
842  errkind = false;
843  switch (pstate->p_expr_kind)
844  {
845  case EXPR_KIND_NONE:
846  Assert(false); /* can't happen */
847  break;
848  case EXPR_KIND_OTHER:
849  /* Accept window func here; caller must throw error if wanted */
850  break;
851  case EXPR_KIND_JOIN_ON:
853  err = _("window functions are not allowed in JOIN conditions");
854  break;
856  /* can't get here, but just in case, throw an error */
857  errkind = true;
858  break;
860  err = _("window functions are not allowed in functions in FROM");
861  break;
862  case EXPR_KIND_WHERE:
863  errkind = true;
864  break;
865  case EXPR_KIND_POLICY:
866  err = _("window functions are not allowed in policy expressions");
867  break;
868  case EXPR_KIND_HAVING:
869  errkind = true;
870  break;
871  case EXPR_KIND_FILTER:
872  errkind = true;
873  break;
879  err = _("window functions are not allowed in window definitions");
880  break;
882  /* okay */
883  break;
887  errkind = true;
888  break;
889  case EXPR_KIND_GROUP_BY:
890  errkind = true;
891  break;
892  case EXPR_KIND_ORDER_BY:
893  /* okay */
894  break;
896  /* okay */
897  break;
898  case EXPR_KIND_LIMIT:
899  case EXPR_KIND_OFFSET:
900  errkind = true;
901  break;
902  case EXPR_KIND_RETURNING:
903  errkind = true;
904  break;
905  case EXPR_KIND_VALUES:
907  errkind = true;
908  break;
911  err = _("window functions are not allowed in check constraints");
912  break;
915  err = _("window functions are not allowed in DEFAULT expressions");
916  break;
918  err = _("window functions are not allowed in index expressions");
919  break;
921  err = _("window functions are not allowed in statistics expressions");
922  break;
924  err = _("window functions are not allowed in index predicates");
925  break;
927  err = _("window functions are not allowed in transform expressions");
928  break;
930  err = _("window functions are not allowed in EXECUTE parameters");
931  break;
933  err = _("window functions are not allowed in trigger WHEN conditions");
934  break;
936  err = _("window functions are not allowed in partition bound");
937  break;
939  err = _("window functions are not allowed in partition key expressions");
940  break;
942  err = _("window functions are not allowed in CALL arguments");
943  break;
945  err = _("window functions are not allowed in COPY FROM WHERE conditions");
946  break;
948  err = _("window functions are not allowed in column generation expressions");
949  break;
951  errkind = true;
952  break;
953 
954  /*
955  * There is intentionally no default: case here, so that the
956  * compiler will warn if we add a new ParseExprKind without
957  * extending this switch. If we do see an unrecognized value at
958  * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
959  * which is sane anyway.
960  */
961  }
962  if (err)
963  ereport(ERROR,
964  (errcode(ERRCODE_WINDOWING_ERROR),
965  errmsg_internal("%s", err),
966  parser_errposition(pstate, wfunc->location)));
967  if (errkind)
968  ereport(ERROR,
969  (errcode(ERRCODE_WINDOWING_ERROR),
970  /* translator: %s is name of a SQL construct, eg GROUP BY */
971  errmsg("window functions are not allowed in %s",
972  ParseExprKindName(pstate->p_expr_kind)),
973  parser_errposition(pstate, wfunc->location)));
974 
975  /*
976  * If the OVER clause just specifies a window name, find that WINDOW
977  * clause (which had better be present). Otherwise, try to match all the
978  * properties of the OVER clause, and make a new entry in the p_windowdefs
979  * list if no luck.
980  */
981  if (windef->name)
982  {
983  Index winref = 0;
984  ListCell *lc;
985 
986  Assert(windef->refname == NULL &&
987  windef->partitionClause == NIL &&
988  windef->orderClause == NIL &&
990 
991  foreach(lc, pstate->p_windowdefs)
992  {
993  WindowDef *refwin = (WindowDef *) lfirst(lc);
994 
995  winref++;
996  if (refwin->name && strcmp(refwin->name, windef->name) == 0)
997  {
998  wfunc->winref = winref;
999  break;
1000  }
1001  }
1002  if (lc == NULL) /* didn't find it? */
1003  ereport(ERROR,
1004  (errcode(ERRCODE_UNDEFINED_OBJECT),
1005  errmsg("window \"%s\" does not exist", windef->name),
1006  parser_errposition(pstate, windef->location)));
1007  }
1008  else
1009  {
1010  Index winref = 0;
1011  ListCell *lc;
1012 
1013  foreach(lc, pstate->p_windowdefs)
1014  {
1015  WindowDef *refwin = (WindowDef *) lfirst(lc);
1016 
1017  winref++;
1018  if (refwin->refname && windef->refname &&
1019  strcmp(refwin->refname, windef->refname) == 0)
1020  /* matched on refname */ ;
1021  else if (!refwin->refname && !windef->refname)
1022  /* matched, no refname */ ;
1023  else
1024  continue;
1025  if (equal(refwin->partitionClause, windef->partitionClause) &&
1026  equal(refwin->orderClause, windef->orderClause) &&
1027  refwin->frameOptions == windef->frameOptions &&
1028  equal(refwin->startOffset, windef->startOffset) &&
1029  equal(refwin->endOffset, windef->endOffset))
1030  {
1031  /* found a duplicate window specification */
1032  wfunc->winref = winref;
1033  break;
1034  }
1035  }
1036  if (lc == NULL) /* didn't find it? */
1037  {
1038  pstate->p_windowdefs = lappend(pstate->p_windowdefs, windef);
1039  wfunc->winref = list_length(pstate->p_windowdefs);
1040  }
1041  }
1042 
1043  pstate->p_hasWindowFuncs = true;
1044 }
List * partitionClause
Definition: parsenodes.h:501
#define NIL
Definition: pg_list.h:65
#define FRAMEOPTION_DEFAULTS
Definition: parsenodes.h:543
List * args
Definition: primnodes.h:390
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:3105
int frameOptions
Definition: parsenodes.h:503
char * name
Definition: parsenodes.h:499
Definition: nodes.h:539
int errcode(int sqlerrcode)
Definition: elog.c:698
int locate_windowfunc(Node *node)
Definition: rewriteManip.c:235
Index winref
Definition: primnodes.h:392
const char * ParseExprKindName(ParseExprKind exprKind)
Definition: parse_expr.c:3006
bool p_hasWindowFuncs
Definition: parse_node.h:209
Node * startOffset
Definition: parsenodes.h:504
#define ERROR
Definition: elog.h:46
int location
Definition: parsenodes.h:506
List * p_windowdefs
Definition: parse_node.h:195
Node * endOffset
Definition: parsenodes.h:505
List * lappend(List *list, void *datum)
Definition: list.c:336
List * orderClause
Definition: parsenodes.h:502
unsigned int Index
Definition: c.h:549
ParseExprKind p_expr_kind
Definition: parse_node.h:196
#define ereport(elevel,...)
Definition: elog.h:157
int errmsg_internal(const char *fmt,...)
Definition: elog.c:996
int location
Definition: primnodes.h:395
#define Assert(condition)
Definition: c.h:804
#define lfirst(lc)
Definition: pg_list.h:169
static int list_length(const List *l)
Definition: pg_list.h:149
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:111
int errmsg(const char *fmt,...)
Definition: elog.c:909
char * refname
Definition: parsenodes.h:500
#define _(x)
Definition: elog.c:89
bool contain_windowfuncs(Node *node)
Definition: rewriteManip.c:197