PostgreSQL Source Code git master
Functions
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 2085 of file parse_agg.c.

2086{
2087 ListCell *lc;
2088
2089 foreach(lc, aggref->args)
2090 {
2091 HeapTuple typeTuple;
2092 Form_pg_type pt;
2093 TargetEntry *tle = (TargetEntry *) lfirst(lc);
2094 Oid type = exprType((Node *) tle->expr);
2095
2096 /*
2097 * RECORD is a special case: it has typsend/typreceive functions, but
2098 * record_recv only works if passed the correct typmod to identify the
2099 * specific anonymous record type. array_agg_deserialize cannot do
2100 * that, so we have to disclaim support for the case.
2101 */
2102 if (type == RECORDOID)
2103 return false;
2104
2105 typeTuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type));
2106 if (!HeapTupleIsValid(typeTuple))
2107 elog(ERROR, "cache lookup failed for type %u", type);
2108
2109 pt = (Form_pg_type) GETSTRUCT(typeTuple);
2110
2111 if (!pt->typbyval &&
2112 (!OidIsValid(pt->typsend) || !OidIsValid(pt->typreceive)))
2113 {
2114 ReleaseSysCache(typeTuple);
2115 return false;
2116 }
2117 ReleaseSysCache(typeTuple);
2118 }
2119 return true;
2120}
#define OidIsValid(objectId)
Definition: c.h:774
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
static void * GETSTRUCT(const HeapTupleData *tuple)
Definition: htup_details.h:728
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
#define lfirst(lc)
Definition: pg_list.h:172
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
unsigned int Oid
Definition: postgres_ext.h:32
List * args
Definition: primnodes.h:487
Definition: nodes.h:135
Expr * expr
Definition: primnodes.h:2238
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:264
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:220
Definition: pg_list.h:46
const char * type

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

2238{
2239 List *args;
2240 FuncExpr *fexpr;
2241
2242 /* deserialfn always takes BYTEA, INTERNAL and returns INTERNAL */
2244 make_agg_arg(INTERNALOID, InvalidOid));
2245
2246 fexpr = makeFuncExpr(deserialfn_oid,
2247 INTERNALOID,
2248 args,
2249 InvalidOid,
2250 InvalidOid,
2252 *deserialfnexpr = (Expr *) fexpr;
2253}
FuncExpr * makeFuncExpr(Oid funcid, Oid rettype, List *args, Oid funccollid, Oid inputcollid, CoercionForm fformat)
Definition: makefuncs.c:594
args
static Node * make_agg_arg(Oid argtype, Oid argcollation)
Definition: parse_agg.c:2300
#define list_make2(x1, x2)
Definition: pg_list.h:214
#define InvalidOid
Definition: postgres_ext.h:37
@ COERCE_EXPLICIT_CALL
Definition: primnodes.h:766
Definition: primnodes.h:189
Definition: pg_list.h:54

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

2267{
2268 List *args;
2269 int i;
2270
2271 /*
2272 * Build expr tree for final function
2273 */
2274 args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
2275
2276 /* finalfn may take additional args, which match agg's input types */
2277 for (i = 0; i < num_finalfn_inputs - 1; i++)
2278 {
2279 args = lappend(args,
2280 make_agg_arg(agg_input_types[i], agg_input_collation));
2281 }
2282
2283 *finalfnexpr = (Expr *) makeFuncExpr(finalfn_oid,
2284 agg_result_type,
2285 args,
2286 InvalidOid,
2287 agg_input_collation,
2289 /* finalfn is currently never treated as variadic */
2290}
i
int i
Definition: isn.c:77
List * lappend(List *list, void *datum)
Definition: list.c:339
#define list_make1(x1)
Definition: pg_list.h:212

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

2215{
2216 List *args;
2217 FuncExpr *fexpr;
2218
2219 /* serialfn always takes INTERNAL and returns BYTEA */
2220 args = list_make1(make_agg_arg(INTERNALOID, InvalidOid));
2221
2222 fexpr = makeFuncExpr(serialfn_oid,
2223 BYTEAOID,
2224 args,
2225 InvalidOid,
2226 InvalidOid,
2228 *serialfnexpr = (Expr *) fexpr;
2229}

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

2162{
2163 List *args;
2164 FuncExpr *fexpr;
2165 int i;
2166
2167 /*
2168 * Build arg list to use in the transfn FuncExpr node.
2169 */
2170 args = list_make1(make_agg_arg(agg_state_type, agg_input_collation));
2171
2172 for (i = agg_num_direct_inputs; i < agg_num_inputs; i++)
2173 {
2174 args = lappend(args,
2175 make_agg_arg(agg_input_types[i], agg_input_collation));
2176 }
2177
2178 fexpr = makeFuncExpr(transfn_oid,
2179 agg_state_type,
2180 args,
2181 InvalidOid,
2182 agg_input_collation,
2184 fexpr->funcvariadic = agg_variadic;
2185 *transfnexpr = (Expr *) fexpr;
2186
2187 /*
2188 * Build invtransfn expression if requested, with same args as transfn
2189 */
2190 if (invtransfnexpr != NULL)
2191 {
2192 if (OidIsValid(invtransfn_oid))
2193 {
2194 fexpr = makeFuncExpr(invtransfn_oid,
2195 agg_state_type,
2196 args,
2197 InvalidOid,
2198 agg_input_collation,
2200 fexpr->funcvariadic = agg_variadic;
2201 *invtransfnexpr = (Expr *) fexpr;
2202 }
2203 else
2204 *invtransfnexpr = NULL;
2205 }
2206}

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

1921{
1922 List *expanded_groups = NIL;
1923 List *result = NIL;
1924 double numsets = 1;
1925 ListCell *lc;
1926
1927 if (groupingSets == NIL)
1928 return NIL;
1929
1930 foreach(lc, groupingSets)
1931 {
1932 List *current_result = NIL;
1933 GroupingSet *gs = lfirst(lc);
1934
1935 current_result = expand_groupingset_node(gs);
1936
1937 Assert(current_result != NIL);
1938
1939 numsets *= list_length(current_result);
1940
1941 if (limit >= 0 && numsets > limit)
1942 return NIL;
1943
1944 expanded_groups = lappend(expanded_groups, current_result);
1945 }
1946
1947 /*
1948 * Do cartesian product between sublists of expanded_groups. While at it,
1949 * remove any duplicate elements from individual grouping sets (we must
1950 * NOT change the number of sets though)
1951 */
1952
1953 foreach(lc, (List *) linitial(expanded_groups))
1954 {
1955 result = lappend(result, list_union_int(NIL, (List *) lfirst(lc)));
1956 }
1957
1958 for_each_from(lc, expanded_groups, 1)
1959 {
1960 List *p = lfirst(lc);
1961 List *new_result = NIL;
1962 ListCell *lc2;
1963
1964 foreach(lc2, result)
1965 {
1966 List *q = lfirst(lc2);
1967 ListCell *lc3;
1968
1969 foreach(lc3, p)
1970 {
1971 new_result = lappend(new_result,
1972 list_union_int(q, (List *) lfirst(lc3)));
1973 }
1974 }
1975 result = new_result;
1976 }
1977
1978 /* Now sort the lists by length and deduplicate if necessary */
1979 if (!groupDistinct || list_length(result) < 2)
1980 list_sort(result, cmp_list_len_asc);
1981 else
1982 {
1983 ListCell *cell;
1984 List *prev;
1985
1986 /* Sort each groupset individually */
1987 foreach(cell, result)
1989
1990 /* Now sort the list of groupsets by length and contents */
1992
1993 /* Finally, remove duplicates */
1994 prev = linitial(result);
1995 for_each_from(cell, result, 1)
1996 {
1997 if (equal(lfirst(cell), prev))
1998 result = foreach_delete_current(result, cell);
1999 else
2000 prev = lfirst(cell);
2001 }
2002 }
2003
2004 return result;
2005}
bool equal(const void *a, const void *b)
Definition: equalfuncs.c:223
Assert(PointerIsAligned(start, uint64))
void list_sort(List *list, list_sort_comparator cmp)
Definition: list.c:1674
int list_int_cmp(const ListCell *p1, const ListCell *p2)
Definition: list.c:1691
List * list_union_int(const List *list1, const List *list2)
Definition: list.c:1113
static int cmp_list_len_asc(const ListCell *a, const ListCell *b)
Definition: parse_agg.c:1876
static int cmp_list_len_contents_asc(const ListCell *a, const ListCell *b)
Definition: parse_agg.c:1886
static List * expand_groupingset_node(GroupingSet *gs)
Definition: parse_agg.c:1774
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
#define foreach_delete_current(lst, var_or_cell)
Definition: pg_list.h:391
#define for_each_from(cell, lst, N)
Definition: pg_list.h:414
#define linitial(l)
Definition: pg_list.h:178

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

2024{
2025 int numArguments = 0;
2026 ListCell *lc;
2027
2028 Assert(list_length(aggref->aggargtypes) <= FUNC_MAX_ARGS);
2029
2030 foreach(lc, aggref->aggargtypes)
2031 {
2032 inputTypes[numArguments++] = lfirst_oid(lc);
2033 }
2034
2035 return numArguments;
2036}
#define FUNC_MAX_ARGS
#define lfirst_oid(lc)
Definition: pg_list.h:174

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

1112{
1113 List *gset_common = NIL;
1114 List *groupClauses = NIL;
1115 List *groupClauseCommonVars = NIL;
1116 bool have_non_var_grouping;
1117 List *func_grouped_rels = NIL;
1118 ListCell *l;
1119 bool hasJoinRTEs;
1120 bool hasSelfRefRTEs;
1121 Node *clause;
1122
1123 /* This should only be called if we found aggregates or grouping */
1124 Assert(pstate->p_hasAggs || qry->groupClause || qry->havingQual || qry->groupingSets);
1125
1126 /*
1127 * If we have grouping sets, expand them and find the intersection of all
1128 * sets.
1129 */
1130 if (qry->groupingSets)
1131 {
1132 /*
1133 * The limit of 4096 is arbitrary and exists simply to avoid resource
1134 * issues from pathological constructs.
1135 */
1136 List *gsets = expand_grouping_sets(qry->groupingSets, qry->groupDistinct, 4096);
1137
1138 if (!gsets)
1139 ereport(ERROR,
1140 (errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
1141 errmsg("too many grouping sets present (maximum 4096)"),
1142 parser_errposition(pstate,
1143 qry->groupClause
1144 ? exprLocation((Node *) qry->groupClause)
1145 : exprLocation((Node *) qry->groupingSets))));
1146
1147 /*
1148 * The intersection will often be empty, so help things along by
1149 * seeding the intersect with the smallest set.
1150 */
1151 gset_common = linitial(gsets);
1152
1153 if (gset_common)
1154 {
1155 for_each_from(l, gsets, 1)
1156 {
1157 gset_common = list_intersection_int(gset_common, lfirst(l));
1158 if (!gset_common)
1159 break;
1160 }
1161 }
1162
1163 /*
1164 * If there was only one grouping set in the expansion, AND if the
1165 * groupClause is non-empty (meaning that the grouping set is not
1166 * empty either), then we can ditch the grouping set and pretend we
1167 * just had a normal GROUP BY.
1168 */
1169 if (list_length(gsets) == 1 && qry->groupClause)
1170 qry->groupingSets = NIL;
1171 }
1172
1173 /*
1174 * Scan the range table to see if there are JOIN or self-reference CTE
1175 * entries. We'll need this info below.
1176 */
1177 hasJoinRTEs = hasSelfRefRTEs = false;
1178 foreach(l, pstate->p_rtable)
1179 {
1180 RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
1181
1182 if (rte->rtekind == RTE_JOIN)
1183 hasJoinRTEs = true;
1184 else if (rte->rtekind == RTE_CTE && rte->self_reference)
1185 hasSelfRefRTEs = true;
1186 }
1187
1188 /*
1189 * Build a list of the acceptable GROUP BY expressions for use by
1190 * substitute_grouped_columns().
1191 *
1192 * We get the TLE, not just the expr, because GROUPING wants to know the
1193 * sortgroupref.
1194 */
1195 foreach(l, qry->groupClause)
1196 {
1197 SortGroupClause *grpcl = (SortGroupClause *) lfirst(l);
1198 TargetEntry *expr;
1199
1200 expr = get_sortgroupclause_tle(grpcl, qry->targetList);
1201 if (expr == NULL)
1202 continue; /* probably cannot happen */
1203
1204 groupClauses = lappend(groupClauses, expr);
1205 }
1206
1207 /*
1208 * If there are join alias vars involved, we have to flatten them to the
1209 * underlying vars, so that aliased and unaliased vars will be correctly
1210 * taken as equal. We can skip the expense of doing this if no rangetable
1211 * entries are RTE_JOIN kind.
1212 */
1213 if (hasJoinRTEs)
1214 groupClauses = (List *) flatten_join_alias_vars(NULL, qry,
1215 (Node *) groupClauses);
1216
1217 /*
1218 * Detect whether any of the grouping expressions aren't simple Vars; if
1219 * they're all Vars then we don't have to work so hard in the recursive
1220 * scans. (Note we have to flatten aliases before this.)
1221 *
1222 * Track Vars that are included in all grouping sets separately in
1223 * groupClauseCommonVars, since these are the only ones we can use to
1224 * check for functional dependencies.
1225 */
1226 have_non_var_grouping = false;
1227 foreach(l, groupClauses)
1228 {
1229 TargetEntry *tle = lfirst(l);
1230
1231 if (!IsA(tle->expr, Var))
1232 {
1233 have_non_var_grouping = true;
1234 }
1235 else if (!qry->groupingSets ||
1236 list_member_int(gset_common, tle->ressortgroupref))
1237 {
1238 groupClauseCommonVars = lappend(groupClauseCommonVars, tle->expr);
1239 }
1240 }
1241
1242 /*
1243 * If there are any acceptable GROUP BY expressions, build an RTE and
1244 * nsitem for the result of the grouping step.
1245 */
1246 if (groupClauses)
1247 {
1248 pstate->p_grouping_nsitem =
1249 addRangeTableEntryForGroup(pstate, groupClauses);
1250
1251 /* Set qry->rtable again in case it was previously NIL */
1252 qry->rtable = pstate->p_rtable;
1253 /* Mark the Query as having RTE_GROUP RTE */
1254 qry->hasGroupRTE = true;
1255 }
1256
1257 /*
1258 * Replace grouped variables in the targetlist and HAVING clause with Vars
1259 * that reference the RTE_GROUP RTE. Emit an error message if we find any
1260 * ungrouped variables.
1261 *
1262 * Note: because we check resjunk tlist elements as well as regular ones,
1263 * this will also find ungrouped variables that came from ORDER BY and
1264 * WINDOW clauses. For that matter, it's also going to examine the
1265 * grouping expressions themselves --- but they'll all pass the test ...
1266 *
1267 * We also finalize GROUPING expressions, but for that we need to traverse
1268 * the original (unflattened) clause in order to modify nodes.
1269 */
1270 clause = (Node *) qry->targetList;
1271 finalize_grouping_exprs(clause, pstate, qry,
1272 groupClauses, hasJoinRTEs,
1273 have_non_var_grouping);
1274 if (hasJoinRTEs)
1275 clause = flatten_join_alias_vars(NULL, qry, clause);
1276 qry->targetList = (List *)
1277 substitute_grouped_columns(clause, pstate, qry,
1278 groupClauses, groupClauseCommonVars,
1279 gset_common,
1280 have_non_var_grouping,
1281 &func_grouped_rels);
1282
1283 clause = (Node *) qry->havingQual;
1284 finalize_grouping_exprs(clause, pstate, qry,
1285 groupClauses, hasJoinRTEs,
1286 have_non_var_grouping);
1287 if (hasJoinRTEs)
1288 clause = flatten_join_alias_vars(NULL, qry, clause);
1289 qry->havingQual =
1290 substitute_grouped_columns(clause, pstate, qry,
1291 groupClauses, groupClauseCommonVars,
1292 gset_common,
1293 have_non_var_grouping,
1294 &func_grouped_rels);
1295
1296 /*
1297 * Per spec, aggregates can't appear in a recursive term.
1298 */
1299 if (pstate->p_hasAggs && hasSelfRefRTEs)
1300 ereport(ERROR,
1301 (errcode(ERRCODE_INVALID_RECURSION),
1302 errmsg("aggregate functions are not allowed in a recursive query's recursive term"),
1303 parser_errposition(pstate,
1304 locate_agg_of_level((Node *) qry, 0))));
1305}
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ereport(elevel,...)
Definition: elog.h:150
List * list_intersection_int(const List *list1, const List *list2)
Definition: list.c:1200
bool list_member_int(const List *list, int datum)
Definition: list.c:702
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1388
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
static void finalize_grouping_exprs(Node *node, ParseState *pstate, Query *qry, List *groupClauses, bool hasJoinRTEs, bool have_non_var_grouping)
Definition: parse_agg.c:1567
List * expand_grouping_sets(List *groupingSets, bool groupDistinct, int limit)
Definition: parse_agg.c:1920
static Node * substitute_grouped_columns(Node *node, ParseState *pstate, Query *qry, List *groupClauses, List *groupClauseCommonVars, List *gset_common, bool have_non_var_grouping, List **func_grouped_rels)
Definition: parse_agg.c:1331
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
ParseNamespaceItem * addRangeTableEntryForGroup(ParseState *pstate, List *groupClauses)
@ RTE_JOIN
Definition: parsenodes.h:1045
@ RTE_CTE
Definition: parsenodes.h:1049
int locate_agg_of_level(Node *node, int levelsup)
Definition: rewriteManip.c:149
ParseNamespaceItem * p_grouping_nsitem
Definition: parse_node.h:211
List * p_rtable
Definition: parse_node.h:196
bool p_hasAggs
Definition: parse_node.h:226
bool groupDistinct
Definition: parsenodes.h:217
List * groupClause
Definition: parsenodes.h:216
Node * havingQual
Definition: parsenodes.h:222
List * rtable
Definition: parsenodes.h:175
List * targetList
Definition: parsenodes.h:198
List * groupingSets
Definition: parsenodes.h:220
RTEKind rtekind
Definition: parsenodes.h:1078
Index ressortgroupref
Definition: primnodes.h:2244
Definition: primnodes.h:262
TargetEntry * get_sortgroupclause_tle(SortGroupClause *sgClause, List *targetList)
Definition: tlist.c:367
Node * flatten_join_alias_vars(PlannerInfo *root, Query *query, Node *node)
Definition: var.c:789

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(), transformSelectStmt(), and transformSetOperationStmt().

◆ resolve_aggregate_transtype()

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

Definition at line 2049 of file parse_agg.c.

2053{
2054 /* resolve actual type of transition state, if polymorphic */
2055 if (IsPolymorphicType(aggtranstype))
2056 {
2057 /* have to fetch the agg's declared input types... */
2058 Oid *declaredArgTypes;
2059 int agg_nargs;
2060
2061 (void) get_func_signature(aggfuncid, &declaredArgTypes, &agg_nargs);
2062
2063 /*
2064 * VARIADIC ANY aggs could have more actual than declared args, but
2065 * such extra args can't affect polymorphic type resolution.
2066 */
2067 Assert(agg_nargs <= numArguments);
2068
2069 aggtranstype = enforce_generic_type_consistency(inputTypes,
2070 declaredArgTypes,
2071 agg_nargs,
2072 aggtranstype,
2073 false);
2074 pfree(declaredArgTypes);
2075 }
2076 return aggtranstype;
2077}
Oid get_func_signature(Oid funcid, Oid **argtypes, int *nargs)
Definition: lsyscache.c:1863
void pfree(void *pointer)
Definition: mcxt.c:1594
Oid enforce_generic_type_consistency(const Oid *actual_arg_types, Oid *declared_arg_types, int nargs, Oid rettype, bool allow_poly)
Definition: parse_coerce.c:2132

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.

111{
112 List *argtypes = NIL;
113 List *tlist = NIL;
114 List *torder = NIL;
115 List *tdistinct = NIL;
116 AttrNumber attno = 1;
117 int save_next_resno;
118 ListCell *lc;
119
120 if (AGGKIND_IS_ORDERED_SET(agg->aggkind))
121 {
122 /*
123 * For an ordered-set agg, the args list includes direct args and
124 * aggregated args; we must split them apart.
125 */
126 int numDirectArgs = list_length(args) - list_length(aggorder);
127 List *aargs;
128 ListCell *lc2;
129
130 Assert(numDirectArgs >= 0);
131
132 aargs = list_copy_tail(args, numDirectArgs);
133 agg->aggdirectargs = list_truncate(args, numDirectArgs);
134
135 /*
136 * Build a tlist from the aggregated args, and make a sortlist entry
137 * for each one. Note that the expressions in the SortBy nodes are
138 * ignored (they are the raw versions of the transformed args); we are
139 * just looking at the sort information in the SortBy nodes.
140 */
141 forboth(lc, aargs, lc2, aggorder)
142 {
143 Expr *arg = (Expr *) lfirst(lc);
144 SortBy *sortby = (SortBy *) lfirst(lc2);
145 TargetEntry *tle;
146
147 /* We don't bother to assign column names to the entries */
148 tle = makeTargetEntry(arg, attno++, NULL, false);
149 tlist = lappend(tlist, tle);
150
151 torder = addTargetToSortList(pstate, tle,
152 torder, tlist, sortby);
153 }
154
155 /* Never any DISTINCT in an ordered-set agg */
156 Assert(!agg_distinct);
157 }
158 else
159 {
160 /* Regular aggregate, so it has no direct args */
161 agg->aggdirectargs = NIL;
162
163 /*
164 * Transform the plain list of Exprs into a targetlist.
165 */
166 foreach(lc, args)
167 {
168 Expr *arg = (Expr *) lfirst(lc);
169 TargetEntry *tle;
170
171 /* We don't bother to assign column names to the entries */
172 tle = makeTargetEntry(arg, attno++, NULL, false);
173 tlist = lappend(tlist, tle);
174 }
175
176 /*
177 * If we have an ORDER BY, transform it. This will add columns to the
178 * tlist if they appear in ORDER BY but weren't already in the arg
179 * list. They will be marked resjunk = true so we can tell them apart
180 * from regular aggregate arguments later.
181 *
182 * We need to mess with p_next_resno since it will be used to number
183 * any new targetlist entries.
184 */
185 save_next_resno = pstate->p_next_resno;
186 pstate->p_next_resno = attno;
187
188 torder = transformSortClause(pstate,
189 aggorder,
190 &tlist,
192 true /* force SQL99 rules */ );
193
194 /*
195 * If we have DISTINCT, transform that to produce a distinctList.
196 */
197 if (agg_distinct)
198 {
199 tdistinct = transformDistinctClause(pstate, &tlist, torder, true);
200
201 /*
202 * Remove this check if executor support for hashed distinct for
203 * aggregates is ever added.
204 */
205 foreach(lc, tdistinct)
206 {
207 SortGroupClause *sortcl = (SortGroupClause *) lfirst(lc);
208
209 if (!OidIsValid(sortcl->sortop))
210 {
211 Node *expr = get_sortgroupclause_expr(sortcl, tlist);
212
214 (errcode(ERRCODE_UNDEFINED_FUNCTION),
215 errmsg("could not identify an ordering operator for type %s",
216 format_type_be(exprType(expr))),
217 errdetail("Aggregates with DISTINCT must be able to sort their inputs."),
218 parser_errposition(pstate, exprLocation(expr))));
219 }
220 }
221 }
222
223 pstate->p_next_resno = save_next_resno;
224 }
225
226 /* Update the Aggref with the transformation results */
227 agg->args = tlist;
228 agg->aggorder = torder;
229 agg->aggdistinct = tdistinct;
230
231 /*
232 * Now build the aggargtypes list with the type OIDs of the direct and
233 * aggregated args, ignoring any resjunk entries that might have been
234 * added by ORDER BY/DISTINCT processing. We can't do this earlier
235 * because said processing can modify some args' data types, in particular
236 * by resolving previously-unresolved "unknown" literals.
237 */
238 foreach(lc, agg->aggdirectargs)
239 {
240 Expr *arg = (Expr *) lfirst(lc);
241
242 argtypes = lappend_oid(argtypes, exprType((Node *) arg));
243 }
244 foreach(lc, tlist)
245 {
246 TargetEntry *tle = (TargetEntry *) lfirst(lc);
247
248 if (tle->resjunk)
249 continue; /* ignore junk */
250 argtypes = lappend_oid(argtypes, exprType((Node *) tle->expr));
251 }
252 agg->aggargtypes = argtypes;
253
254 check_agglevels_and_constraints(pstate, (Node *) agg);
255}
int16 AttrNumber
Definition: attnum.h:21
int errdetail(const char *fmt,...)
Definition: elog.c:1207
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
List * list_copy_tail(const List *oldlist, int nskip)
Definition: list.c:1613
List * lappend_oid(List *list, Oid datum)
Definition: list.c:375
List * list_truncate(List *list, int new_size)
Definition: list.c:631
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition: makefuncs.c:289
static void check_agglevels_and_constraints(ParseState *pstate, Node *expr)
Definition: parse_agg.c:304
List * transformSortClause(ParseState *pstate, List *orderlist, List **targetlist, ParseExprKind exprKind, bool useSQL99)
Definition: parse_clause.c:2794
List * transformDistinctClause(ParseState *pstate, List **targetlist, List *sortClause, bool is_agg)
Definition: parse_clause.c:3048
List * addTargetToSortList(ParseState *pstate, TargetEntry *tle, List *sortlist, List *targetlist, SortBy *sortby)
Definition: parse_clause.c:3456
@ EXPR_KIND_ORDER_BY
Definition: parse_node.h:60
void * arg
#define forboth(cell1, list1, cell2, list2)
Definition: pg_list.h:518
List * aggdistinct
Definition: primnodes.h:493
List * aggdirectargs
Definition: primnodes.h:484
List * aggorder
Definition: primnodes.h:490
int p_next_resno
Definition: parse_node.h:215
Node * get_sortgroupclause_expr(SortGroupClause *sgClause, List *targetList)
Definition: tlist.c:379

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.

266{
267 ListCell *lc;
268 List *args = p->args;
269 List *result_list = NIL;
271
272 if (list_length(args) > 31)
274 (errcode(ERRCODE_TOO_MANY_ARGUMENTS),
275 errmsg("GROUPING must have fewer than 32 arguments"),
276 parser_errposition(pstate, p->location)));
277
278 foreach(lc, args)
279 {
280 Node *current_result;
281
282 current_result = transformExpr(pstate, (Node *) lfirst(lc), pstate->p_expr_kind);
283
284 /* acceptability of expressions is checked later */
285
286 result_list = lappend(result_list, current_result);
287 }
288
289 result->args = result_list;
290 result->location = p->location;
291
292 check_agglevels_and_constraints(pstate, (Node *) result);
293
294 return (Node *) result;
295}
#define makeNode(_type_)
Definition: nodes.h:161
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:118
ParseLoc location
Definition: primnodes.h:573
ParseExprKind p_expr_kind
Definition: parse_node.h:214

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

853{
854 const char *err;
855 bool errkind;
856
857 /*
858 * A window function call can't contain another one (but aggs are OK). XXX
859 * is this required by spec, or just an unimplemented feature?
860 *
861 * Note: we don't need to check the filter expression here, because the
862 * context checks done below and in transformAggregateCall would have
863 * already rejected any window funcs or aggs within the filter.
864 */
865 if (pstate->p_hasWindowFuncs &&
866 contain_windowfuncs((Node *) wfunc->args))
868 (errcode(ERRCODE_WINDOWING_ERROR),
869 errmsg("window function calls cannot be nested"),
870 parser_errposition(pstate,
871 locate_windowfunc((Node *) wfunc->args))));
872
873 /*
874 * Check to see if the window function is in an invalid place within the
875 * query.
876 *
877 * For brevity we support two schemes for reporting an error here: set
878 * "err" to a custom message, or set "errkind" true if the error context
879 * is sufficiently identified by what ParseExprKindName will return, *and*
880 * what it will return is just a SQL keyword. (Otherwise, use a custom
881 * message to avoid creating translation problems.)
882 */
883 err = NULL;
884 errkind = false;
885 switch (pstate->p_expr_kind)
886 {
887 case EXPR_KIND_NONE:
888 Assert(false); /* can't happen */
889 break;
890 case EXPR_KIND_OTHER:
891 /* Accept window func here; caller must throw error if wanted */
892 break;
895 err = _("window functions are not allowed in JOIN conditions");
896 break;
898 /* can't get here, but just in case, throw an error */
899 errkind = true;
900 break;
902 err = _("window functions are not allowed in functions in FROM");
903 break;
904 case EXPR_KIND_WHERE:
905 errkind = true;
906 break;
907 case EXPR_KIND_POLICY:
908 err = _("window functions are not allowed in policy expressions");
909 break;
910 case EXPR_KIND_HAVING:
911 errkind = true;
912 break;
913 case EXPR_KIND_FILTER:
914 errkind = true;
915 break;
921 err = _("window functions are not allowed in window definitions");
922 break;
924 /* okay */
925 break;
929 errkind = true;
930 break;
932 err = _("window functions are not allowed in MERGE WHEN conditions");
933 break;
935 errkind = true;
936 break;
938 /* okay */
939 break;
941 /* okay */
942 break;
943 case EXPR_KIND_LIMIT:
944 case EXPR_KIND_OFFSET:
945 errkind = true;
946 break;
949 errkind = true;
950 break;
951 case EXPR_KIND_VALUES:
953 errkind = true;
954 break;
957 err = _("window functions are not allowed in check constraints");
958 break;
961 err = _("window functions are not allowed in DEFAULT expressions");
962 break;
964 err = _("window functions are not allowed in index expressions");
965 break;
967 err = _("window functions are not allowed in statistics expressions");
968 break;
970 err = _("window functions are not allowed in index predicates");
971 break;
973 err = _("window functions are not allowed in transform expressions");
974 break;
976 err = _("window functions are not allowed in EXECUTE parameters");
977 break;
979 err = _("window functions are not allowed in trigger WHEN conditions");
980 break;
982 err = _("window functions are not allowed in partition bound");
983 break;
985 err = _("window functions are not allowed in partition key expressions");
986 break;
988 err = _("window functions are not allowed in CALL arguments");
989 break;
991 err = _("window functions are not allowed in COPY FROM WHERE conditions");
992 break;
994 err = _("window functions are not allowed in column generation expressions");
995 break;
997 errkind = true;
998 break;
999
1000 /*
1001 * There is intentionally no default: case here, so that the
1002 * compiler will warn if we add a new ParseExprKind without
1003 * extending this switch. If we do see an unrecognized value at
1004 * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
1005 * which is sane anyway.
1006 */
1007 }
1008 if (err)
1009 ereport(ERROR,
1010 (errcode(ERRCODE_WINDOWING_ERROR),
1011 errmsg_internal("%s", err),
1012 parser_errposition(pstate, wfunc->location)));
1013 if (errkind)
1014 ereport(ERROR,
1015 (errcode(ERRCODE_WINDOWING_ERROR),
1016 /* translator: %s is name of a SQL construct, eg GROUP BY */
1017 errmsg("window functions are not allowed in %s",
1019 parser_errposition(pstate, wfunc->location)));
1020
1021 /*
1022 * If the OVER clause just specifies a window name, find that WINDOW
1023 * clause (which had better be present). Otherwise, try to match all the
1024 * properties of the OVER clause, and make a new entry in the p_windowdefs
1025 * list if no luck.
1026 */
1027 if (windef->name)
1028 {
1029 Index winref = 0;
1030 ListCell *lc;
1031
1032 Assert(windef->refname == NULL &&
1033 windef->partitionClause == NIL &&
1034 windef->orderClause == NIL &&
1036
1037 foreach(lc, pstate->p_windowdefs)
1038 {
1039 WindowDef *refwin = (WindowDef *) lfirst(lc);
1040
1041 winref++;
1042 if (refwin->name && strcmp(refwin->name, windef->name) == 0)
1043 {
1044 wfunc->winref = winref;
1045 break;
1046 }
1047 }
1048 if (lc == NULL) /* didn't find it? */
1049 ereport(ERROR,
1050 (errcode(ERRCODE_UNDEFINED_OBJECT),
1051 errmsg("window \"%s\" does not exist", windef->name),
1052 parser_errposition(pstate, windef->location)));
1053 }
1054 else
1055 {
1056 Index winref = 0;
1057 ListCell *lc;
1058
1059 foreach(lc, pstate->p_windowdefs)
1060 {
1061 WindowDef *refwin = (WindowDef *) lfirst(lc);
1062
1063 winref++;
1064 if (refwin->refname && windef->refname &&
1065 strcmp(refwin->refname, windef->refname) == 0)
1066 /* matched on refname */ ;
1067 else if (!refwin->refname && !windef->refname)
1068 /* matched, no refname */ ;
1069 else
1070 continue;
1071
1072 /*
1073 * Also see similar de-duplication code in optimize_window_clauses
1074 */
1075 if (equal(refwin->partitionClause, windef->partitionClause) &&
1076 equal(refwin->orderClause, windef->orderClause) &&
1077 refwin->frameOptions == windef->frameOptions &&
1078 equal(refwin->startOffset, windef->startOffset) &&
1079 equal(refwin->endOffset, windef->endOffset))
1080 {
1081 /* found a duplicate window specification */
1082 wfunc->winref = winref;
1083 break;
1084 }
1085 }
1086 if (lc == NULL) /* didn't find it? */
1087 {
1088 pstate->p_windowdefs = lappend(pstate->p_windowdefs, windef);
1089 wfunc->winref = list_length(pstate->p_windowdefs);
1090 }
1091 }
1092
1093 pstate->p_hasWindowFuncs = true;
1094}
unsigned int Index
Definition: c.h:619
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1161
_
#define _(x)
Definition: elog.c:91
void err(int eval, const char *fmt,...)
Definition: err.c:43
const char * ParseExprKindName(ParseExprKind exprKind)
Definition: parse_expr.c:3133
@ EXPR_KIND_EXECUTE_PARAMETER
Definition: parse_node.h:76
@ EXPR_KIND_DOMAIN_CHECK
Definition: parse_node.h:69
@ EXPR_KIND_COPY_WHERE
Definition: parse_node.h:82
@ EXPR_KIND_COLUMN_DEFAULT
Definition: parse_node.h:70
@ EXPR_KIND_DISTINCT_ON
Definition: parse_node.h:61
@ EXPR_KIND_MERGE_WHEN
Definition: parse_node.h:58
@ EXPR_KIND_STATS_EXPRESSION
Definition: parse_node.h:74
@ EXPR_KIND_INDEX_EXPRESSION
Definition: parse_node.h:72
@ EXPR_KIND_MERGE_RETURNING
Definition: parse_node.h:65
@ EXPR_KIND_PARTITION_BOUND
Definition: parse_node.h:79
@ EXPR_KIND_FUNCTION_DEFAULT
Definition: parse_node.h:71
@ EXPR_KIND_WINDOW_FRAME_RANGE
Definition: parse_node.h:51
@ EXPR_KIND_VALUES
Definition: parse_node.h:66
@ EXPR_KIND_FROM_SUBSELECT
Definition: parse_node.h:44
@ EXPR_KIND_POLICY
Definition: parse_node.h:78
@ EXPR_KIND_WINDOW_FRAME_GROUPS
Definition: parse_node.h:53
@ EXPR_KIND_PARTITION_EXPRESSION
Definition: parse_node.h:80
@ EXPR_KIND_JOIN_USING
Definition: parse_node.h:43
@ EXPR_KIND_INDEX_PREDICATE
Definition: parse_node.h:73
@ EXPR_KIND_OFFSET
Definition: parse_node.h:63
@ EXPR_KIND_JOIN_ON
Definition: parse_node.h:42
@ EXPR_KIND_HAVING
Definition: parse_node.h:47
@ EXPR_KIND_INSERT_TARGET
Definition: parse_node.h:55
@ EXPR_KIND_ALTER_COL_TRANSFORM
Definition: parse_node.h:75
@ EXPR_KIND_LIMIT
Definition: parse_node.h:62
@ EXPR_KIND_WHERE
Definition: parse_node.h:46
@ EXPR_KIND_UPDATE_TARGET
Definition: parse_node.h:57
@ EXPR_KIND_SELECT_TARGET
Definition: parse_node.h:54
@ EXPR_KIND_RETURNING
Definition: parse_node.h:64
@ EXPR_KIND_GENERATED_COLUMN
Definition: parse_node.h:83
@ EXPR_KIND_NONE
Definition: parse_node.h:40
@ EXPR_KIND_CALL_ARGUMENT
Definition: parse_node.h:81
@ EXPR_KIND_GROUP_BY
Definition: parse_node.h:59
@ EXPR_KIND_OTHER
Definition: parse_node.h:41
@ EXPR_KIND_FROM_FUNCTION
Definition: parse_node.h:45
@ EXPR_KIND_TRIGGER_WHEN
Definition: parse_node.h:77
@ EXPR_KIND_FILTER
Definition: parse_node.h:48
@ EXPR_KIND_UPDATE_SOURCE
Definition: parse_node.h:56
@ EXPR_KIND_CHECK_CONSTRAINT
Definition: parse_node.h:68
@ EXPR_KIND_WINDOW_PARTITION
Definition: parse_node.h:49
@ EXPR_KIND_CYCLE_MARK
Definition: parse_node.h:84
@ EXPR_KIND_WINDOW_FRAME_ROWS
Definition: parse_node.h:52
@ EXPR_KIND_WINDOW_ORDER
Definition: parse_node.h:50
@ EXPR_KIND_VALUES_SINGLE
Definition: parse_node.h:67
#define FRAMEOPTION_DEFAULTS
Definition: parsenodes.h:636
bool contain_windowfuncs(Node *node)
Definition: rewriteManip.c:214
int locate_windowfunc(Node *node)
Definition: rewriteManip.c:251
bool p_hasWindowFuncs
Definition: parse_node.h:227
List * p_windowdefs
Definition: parse_node.h:213
List * orderClause
Definition: parsenodes.h:595
ParseLoc location
Definition: parsenodes.h:599
List * partitionClause
Definition: parsenodes.h:594
Node * startOffset
Definition: parsenodes.h:597
char * refname
Definition: parsenodes.h:593
Node * endOffset
Definition: parsenodes.h:598
int frameOptions
Definition: parsenodes.h:596
char * name
Definition: parsenodes.h:592
List * args
Definition: primnodes.h:605
Index winref
Definition: primnodes.h:611
ParseLoc location
Definition: primnodes.h:619

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().

AltStyle によって変換されたページ (->オリジナル) /