postgres/src/include/parser/parse_agg.h

/*-------------------------------------------------------------------------
 *
 * parse_agg.h
 *	  handle aggregates and window functions in parser
 *
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * $PostgreSQL: pgsql/src/include/parser/parse_agg.h,v 1.40 2009/12/15 17:57:47 tgl Exp $
 *
 *-------------------------------------------------------------------------
 */
#ifndef PARSE_AGG_H
#define PARSE_AGG_H

#include "parser/parse_node.h"

extern void transformAggregateCall(ParseState *pstate, Aggref *agg,
								   bool agg_distinct);
extern void transformWindowFuncCall(ParseState *pstate, WindowFunc *wfunc,
						WindowDef *windef);

extern void parseCheckAggregates(ParseState *pstate, Query *qry);
extern void parseCheckWindowFuncs(ParseState *pstate, Query *qry);

extern void build_aggregate_fnexprs(Oid *agg_input_types,
						int agg_num_inputs,
						Oid agg_state_type,
						Oid agg_result_type,
						Oid transfn_oid,
						Oid finalfn_oid,
						Expr **transfnexpr,
						Expr **finalfnexpr);

#endif   /* PARSE_AGG_H */
Break parser functions into smaller files, group together. 1997-11-25 22:07:18 +00:00			`/*-------------------------------------------------------------------------`
			`*`
			`* parse_agg.h`
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom. 2008-12-28 18:54:01 +00:00			`* handle aggregates and window functions in parser`
Break parser functions into smaller files, group together. 1997-11-25 22:07:18 +00:00			`*`
Update copyright for 2009. 2009-01-01 17:24:05 +00:00			`* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group`
Add: * Portions Copyright (c) 1996-2000, PostgreSQL, Inc to all files copyright Regents of Berkeley. Man, that's a lot of files. 2000-01-26 05:58:53 +00:00			`* Portions Copyright (c) 1994, Regents of the University of California`
Break parser functions into smaller files, group together. 1997-11-25 22:07:18 +00:00			`*`
Support ORDER BY within aggregate function calls, at long last providing a non-kluge method for controlling the order in which values are fed to an aggregate function. At the same time eliminate the old implementation restriction that DISTINCT was only supported for single-argument aggregates. Possibly release-notable behavioral change: formerly, agg(DISTINCT x) dropped null values of x unconditionally. Now, it does so only if the agg transition function is strict; otherwise nulls are treated as DISTINCT normally would, ie, you get one copy. Andrew Gierth, reviewed by Hitoshi Harada 2009-12-15 17:57:48 +00:00			`* $PostgreSQL: pgsql/src/include/parser/parse_agg.h,v 1.40 2009/12/15 17:57:47 tgl Exp $`
Break parser functions into smaller files, group together. 1997-11-25 22:07:18 +00:00			`*`
			`*-------------------------------------------------------------------------`
			`*/`
			`#ifndef PARSE_AGG_H`
			`#define PARSE_AGG_H`

Change #include's to use <> and "" as appropriate. 1999-07-15 23:04:24 +00:00			`#include "parser/parse_node.h"`
Break parser functions into smaller files, group together. 1997-11-25 22:07:18 +00:00
Support ORDER BY within aggregate function calls, at long last providing a non-kluge method for controlling the order in which values are fed to an aggregate function. At the same time eliminate the old implementation restriction that DISTINCT was only supported for single-argument aggregates. Possibly release-notable behavioral change: formerly, agg(DISTINCT x) dropped null values of x unconditionally. Now, it does so only if the agg transition function is strict; otherwise nulls are treated as DISTINCT normally would, ie, you get one copy. Andrew Gierth, reviewed by Hitoshi Harada 2009-12-15 17:57:48 +00:00			`extern void transformAggregateCall(ParseState pstate, Aggref agg,`
			`bool agg_distinct);`
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom. 2008-12-28 18:54:01 +00:00			`extern void transformWindowFuncCall(ParseState pstate, WindowFunc wfunc,`
8.4 pgindent run, with new combined Linux/FreeBSD/MinGW typedef list provided by Andrew. 2009-06-11 14:49:15 +00:00			`WindowDef *windef);`
Implement outer-level aggregates to conform to the SQL spec, with extensions to support our historical behavior. An aggregate belongs to the closest query level of any of the variables in its argument, or the current query level if there are no variables (e.g., COUNT(*)). The implementation involves adding an agglevelsup field to Aggref, and treating outer aggregates like outer variables at planning time. 2003-06-06 15:04:03 +00:00
Fix parse_agg.c to detect ungrouped Vars in sub-SELECTs; remove code that used to do it in planner. That was an ancient kluge that was never satisfactory; errors should be detected at parse time when possible. But at the time we didn't have the support mechanism (expression_tree_walker et al) to make it convenient to do in the parser. 2003-01-17 03:25:04 +00:00			`extern void parseCheckAggregates(ParseState pstate, Query qry);`
Support window functions a la SQL:2008. Hitoshi Harada, with some kibitzing from Heikki and Tom. 2008-12-28 18:54:01 +00:00			`extern void parseCheckWindowFuncs(ParseState pstate, Query qry);`
Another pgindent run. Fixes enum indenting, and improves #endif spacing. Also adds space for one-line comments. 2001-10-28 06:26:15 +00:00
Aggregate functions now support multiple input arguments. I also took the opportunity to treat COUNT(*) as a zero-argument aggregate instead of the old hack that equated it to COUNT(1); this is materially cleaner (no more weird ANYOID cases) and ought to be at least a tiny bit faster. Original patch by Sergey Koposov; review, documentation, simple regression tests, pg_dump and psql support by moi. 2006-07-27 19:52:07 +00:00			`extern void build_aggregate_fnexprs(Oid *agg_input_types,`
			`int agg_num_inputs,`
pgindent run. 2003-08-04 00:43:34 +00:00			`Oid agg_state_type,`
			`Oid agg_result_type,`
			`Oid transfn_oid,`
			`Oid finalfn_oid,`
			`Expr **transfnexpr,`
			`Expr **finalfnexpr);`
Aggregates can be polymorphic, using polymorphic implementation functions. It also works to create a non-polymorphic aggregate from polymorphic functions, should you want to do that. Regression test added, docs still lacking. By Joe Conway, with some kibitzing from Tom Lane. 2003-07-01 19:10:53 +00:00
New pgindent run with fixes suggested by Tom. Patch manually reviewed, initdb/regression tests pass. 2001-11-05 17:46:40 +00:00			`#endif /* PARSE_AGG_H */`