1997-04-27 19:40:13 +02:00
|
|
|
--
|
|
|
|
-- AGGREGATES
|
|
|
|
--
|
2000-01-05 18:32:29 +01:00
|
|
|
|
1997-04-27 19:40:13 +02:00
|
|
|
SELECT avg(four) AS avg_1 FROM onek;
|
|
|
|
|
1997-04-29 16:29:16 +02:00
|
|
|
SELECT avg(a) AS avg_32 FROM aggtest WHERE a < 100;
|
1997-04-27 19:40:13 +02:00
|
|
|
|
2000-07-17 05:05:41 +02:00
|
|
|
-- In 7.1, avg(float4) is computed using float8 arithmetic.
|
|
|
|
-- Round the result to 3 digits to avoid platform-specific results.
|
|
|
|
|
|
|
|
SELECT avg(b)::numeric(10,3) AS avg_107_943 FROM aggtest;
|
1997-04-27 19:40:13 +02:00
|
|
|
|
2000-06-10 07:19:26 +02:00
|
|
|
SELECT avg(gpa) AS avg_3_4 FROM ONLY student;
|
1997-04-27 19:40:13 +02:00
|
|
|
|
|
|
|
|
|
|
|
SELECT sum(four) AS sum_1500 FROM onek;
|
|
|
|
SELECT sum(a) AS sum_198 FROM aggtest;
|
|
|
|
SELECT sum(b) AS avg_431_773 FROM aggtest;
|
2000-06-10 07:19:26 +02:00
|
|
|
SELECT sum(gpa) AS avg_6_8 FROM ONLY student;
|
1997-04-27 19:40:13 +02:00
|
|
|
|
|
|
|
SELECT max(four) AS max_3 FROM onek;
|
|
|
|
SELECT max(a) AS max_100 FROM aggtest;
|
|
|
|
SELECT max(aggtest.b) AS max_324_78 FROM aggtest;
|
|
|
|
SELECT max(student.gpa) AS max_3_7 FROM student;
|
|
|
|
|
2006-03-10 21:15:28 +01:00
|
|
|
SELECT stddev_pop(b) FROM aggtest;
|
|
|
|
SELECT stddev_samp(b) FROM aggtest;
|
|
|
|
SELECT var_pop(b) FROM aggtest;
|
|
|
|
SELECT var_samp(b) FROM aggtest;
|
1997-04-27 19:40:13 +02:00
|
|
|
|
2006-03-10 21:15:28 +01:00
|
|
|
SELECT stddev_pop(b::numeric) FROM aggtest;
|
|
|
|
SELECT stddev_samp(b::numeric) FROM aggtest;
|
|
|
|
SELECT var_pop(b::numeric) FROM aggtest;
|
|
|
|
SELECT var_samp(b::numeric) FROM aggtest;
|
|
|
|
|
|
|
|
-- population variance is defined for a single tuple, sample variance
|
|
|
|
-- is not
|
|
|
|
SELECT var_pop(1.0), var_samp(2.0);
|
|
|
|
SELECT stddev_pop(3.0::numeric), stddev_samp(4.0::numeric);
|
1997-04-27 19:40:13 +02:00
|
|
|
|
Improve performance of numeric sum(), avg(), stddev(), variance(), etc.
This patch improves performance of most built-in aggregates that formerly
used a NUMERIC or NUMERIC array as their transition type; this includes
not only aggregates on numeric inputs, but some aggregates on integer
inputs where overflow of an int8 value is a possibility. The code now
uses a special-purpose data structure to avoid array construction and
deconstruction overhead, as well as packing and unpacking overhead for
numeric values.
These aggregates' transition type is now declared as INTERNAL, since
it doesn't correspond to any SQL data type. To keep the planner from
thinking that that means a lot of storage will be used, we make use
of the just-added pg_aggregate.aggtransspace feature. The space estimate
is set to 128 bytes, which is at least in the right ballpark.
Hadi Moshayedi, reviewed by Pavel Stehule and Tomas Vondra
2013-11-17 00:46:34 +01:00
|
|
|
-- verify correct results for null and NaN inputs
|
|
|
|
select sum(null::int4) from generate_series(1,3);
|
|
|
|
select sum(null::int8) from generate_series(1,3);
|
|
|
|
select sum(null::numeric) from generate_series(1,3);
|
|
|
|
select sum(null::float8) from generate_series(1,3);
|
|
|
|
select avg(null::int4) from generate_series(1,3);
|
|
|
|
select avg(null::int8) from generate_series(1,3);
|
|
|
|
select avg(null::numeric) from generate_series(1,3);
|
|
|
|
select avg(null::float8) from generate_series(1,3);
|
|
|
|
select sum('NaN'::numeric) from generate_series(1,3);
|
|
|
|
select avg('NaN'::numeric) from generate_series(1,3);
|
|
|
|
|
2006-07-28 20:33:04 +02:00
|
|
|
-- SQL2003 binary aggregates
|
|
|
|
SELECT regr_count(b, a) FROM aggtest;
|
|
|
|
SELECT regr_sxx(b, a) FROM aggtest;
|
|
|
|
SELECT regr_syy(b, a) FROM aggtest;
|
|
|
|
SELECT regr_sxy(b, a) FROM aggtest;
|
|
|
|
SELECT regr_avgx(b, a), regr_avgy(b, a) FROM aggtest;
|
|
|
|
SELECT regr_r2(b, a) FROM aggtest;
|
|
|
|
SELECT regr_slope(b, a), regr_intercept(b, a) FROM aggtest;
|
|
|
|
SELECT covar_pop(b, a), covar_samp(b, a) FROM aggtest;
|
|
|
|
SELECT corr(b, a) FROM aggtest;
|
|
|
|
|
2006-03-10 21:15:28 +01:00
|
|
|
SELECT count(four) AS cnt_1000 FROM onek;
|
1999-12-13 02:27:21 +01:00
|
|
|
SELECT count(DISTINCT four) AS cnt_4 FROM onek;
|
|
|
|
|
2002-11-21 01:42:20 +01:00
|
|
|
select ten, count(*), sum(four) from onek
|
|
|
|
group by ten order by ten;
|
1999-12-13 02:27:21 +01:00
|
|
|
|
2002-11-21 01:42:20 +01:00
|
|
|
select ten, count(four), sum(DISTINCT four) from onek
|
|
|
|
group by ten order by ten;
|
1999-12-13 02:27:21 +01:00
|
|
|
|
2006-07-27 21:52:07 +02:00
|
|
|
-- user-defined aggregates
|
1997-04-27 19:40:13 +02:00
|
|
|
SELECT newavg(four) AS avg_1 FROM onek;
|
|
|
|
SELECT newsum(four) AS sum_1500 FROM onek;
|
|
|
|
SELECT newcnt(four) AS cnt_1000 FROM onek;
|
2006-07-27 21:52:07 +02:00
|
|
|
SELECT newcnt(*) AS cnt_1000 FROM onek;
|
|
|
|
SELECT oldcnt(*) AS cnt_1000 FROM onek;
|
|
|
|
SELECT sum2(q1,q2) FROM int8_tbl;
|
2003-06-06 17:04:03 +02:00
|
|
|
|
|
|
|
-- test for outer-level aggregates
|
|
|
|
|
|
|
|
-- this should work
|
|
|
|
select ten, sum(distinct four) from onek a
|
|
|
|
group by ten
|
|
|
|
having exists (select 1 from onek b where sum(distinct a.four) = b.four);
|
|
|
|
|
|
|
|
-- this should fail because subquery has an agg of its own in WHERE
|
|
|
|
select ten, sum(distinct four) from onek a
|
|
|
|
group by ten
|
|
|
|
having exists (select 1 from onek b
|
|
|
|
where sum(distinct a.four + b.four) = b.four);
|
2004-05-26 17:26:28 +02:00
|
|
|
|
2009-04-25 18:44:56 +02:00
|
|
|
-- Test handling of sublinks within outer-level aggregates.
|
|
|
|
-- Per bug report from Daniel Grace.
|
|
|
|
select
|
|
|
|
(select max((select i.unique2 from tenk1 i where i.unique1 = o.unique1)))
|
|
|
|
from tenk1 o;
|
|
|
|
|
2004-05-26 17:26:28 +02:00
|
|
|
--
|
|
|
|
-- test for bitwise integer aggregates
|
|
|
|
--
|
|
|
|
CREATE TEMPORARY TABLE bitwise_test(
|
|
|
|
i2 INT2,
|
|
|
|
i4 INT4,
|
|
|
|
i8 INT8,
|
|
|
|
i INTEGER,
|
|
|
|
x INT2,
|
|
|
|
y BIT(4)
|
|
|
|
);
|
|
|
|
|
|
|
|
-- empty case
|
2010-11-23 21:27:50 +01:00
|
|
|
SELECT
|
2004-05-26 17:26:28 +02:00
|
|
|
BIT_AND(i2) AS "?",
|
|
|
|
BIT_OR(i4) AS "?"
|
|
|
|
FROM bitwise_test;
|
|
|
|
|
|
|
|
COPY bitwise_test FROM STDIN NULL 'null';
|
|
|
|
1 1 1 1 1 B0101
|
|
|
|
3 3 3 null 2 B0100
|
|
|
|
7 7 7 3 4 B1100
|
|
|
|
\.
|
|
|
|
|
|
|
|
SELECT
|
|
|
|
BIT_AND(i2) AS "1",
|
|
|
|
BIT_AND(i4) AS "1",
|
|
|
|
BIT_AND(i8) AS "1",
|
|
|
|
BIT_AND(i) AS "?",
|
|
|
|
BIT_AND(x) AS "0",
|
|
|
|
BIT_AND(y) AS "0100",
|
|
|
|
|
|
|
|
BIT_OR(i2) AS "7",
|
|
|
|
BIT_OR(i4) AS "7",
|
|
|
|
BIT_OR(i8) AS "7",
|
|
|
|
BIT_OR(i) AS "?",
|
|
|
|
BIT_OR(x) AS "7",
|
|
|
|
BIT_OR(y) AS "1101"
|
|
|
|
FROM bitwise_test;
|
|
|
|
|
|
|
|
--
|
|
|
|
-- test boolean aggregates
|
|
|
|
--
|
|
|
|
-- first test all possible transition and final states
|
|
|
|
|
|
|
|
SELECT
|
|
|
|
-- boolean and transitions
|
|
|
|
-- null because strict
|
|
|
|
booland_statefunc(NULL, NULL) IS NULL AS "t",
|
|
|
|
booland_statefunc(TRUE, NULL) IS NULL AS "t",
|
|
|
|
booland_statefunc(FALSE, NULL) IS NULL AS "t",
|
|
|
|
booland_statefunc(NULL, TRUE) IS NULL AS "t",
|
|
|
|
booland_statefunc(NULL, FALSE) IS NULL AS "t",
|
|
|
|
-- and actual computations
|
|
|
|
booland_statefunc(TRUE, TRUE) AS "t",
|
|
|
|
NOT booland_statefunc(TRUE, FALSE) AS "t",
|
|
|
|
NOT booland_statefunc(FALSE, TRUE) AS "t",
|
|
|
|
NOT booland_statefunc(FALSE, FALSE) AS "t";
|
|
|
|
|
|
|
|
SELECT
|
|
|
|
-- boolean or transitions
|
|
|
|
-- null because strict
|
|
|
|
boolor_statefunc(NULL, NULL) IS NULL AS "t",
|
|
|
|
boolor_statefunc(TRUE, NULL) IS NULL AS "t",
|
|
|
|
boolor_statefunc(FALSE, NULL) IS NULL AS "t",
|
|
|
|
boolor_statefunc(NULL, TRUE) IS NULL AS "t",
|
|
|
|
boolor_statefunc(NULL, FALSE) IS NULL AS "t",
|
|
|
|
-- actual computations
|
|
|
|
boolor_statefunc(TRUE, TRUE) AS "t",
|
|
|
|
boolor_statefunc(TRUE, FALSE) AS "t",
|
|
|
|
boolor_statefunc(FALSE, TRUE) AS "t",
|
|
|
|
NOT boolor_statefunc(FALSE, FALSE) AS "t";
|
|
|
|
|
2010-11-23 21:27:50 +01:00
|
|
|
CREATE TEMPORARY TABLE bool_test(
|
2004-05-26 17:26:28 +02:00
|
|
|
b1 BOOL,
|
|
|
|
b2 BOOL,
|
|
|
|
b3 BOOL,
|
|
|
|
b4 BOOL);
|
|
|
|
|
|
|
|
-- empty case
|
|
|
|
SELECT
|
|
|
|
BOOL_AND(b1) AS "n",
|
|
|
|
BOOL_OR(b3) AS "n"
|
|
|
|
FROM bool_test;
|
|
|
|
|
|
|
|
COPY bool_test FROM STDIN NULL 'null';
|
|
|
|
TRUE null FALSE null
|
|
|
|
FALSE TRUE null null
|
|
|
|
null TRUE FALSE null
|
|
|
|
\.
|
|
|
|
|
|
|
|
SELECT
|
|
|
|
BOOL_AND(b1) AS "f",
|
|
|
|
BOOL_AND(b2) AS "t",
|
|
|
|
BOOL_AND(b3) AS "f",
|
|
|
|
BOOL_AND(b4) AS "n",
|
|
|
|
BOOL_AND(NOT b2) AS "f",
|
|
|
|
BOOL_AND(NOT b3) AS "t"
|
|
|
|
FROM bool_test;
|
|
|
|
|
|
|
|
SELECT
|
|
|
|
EVERY(b1) AS "f",
|
|
|
|
EVERY(b2) AS "t",
|
|
|
|
EVERY(b3) AS "f",
|
|
|
|
EVERY(b4) AS "n",
|
|
|
|
EVERY(NOT b2) AS "f",
|
|
|
|
EVERY(NOT b3) AS "t"
|
|
|
|
FROM bool_test;
|
|
|
|
|
|
|
|
SELECT
|
|
|
|
BOOL_OR(b1) AS "t",
|
|
|
|
BOOL_OR(b2) AS "t",
|
|
|
|
BOOL_OR(b3) AS "f",
|
|
|
|
BOOL_OR(b4) AS "n",
|
|
|
|
BOOL_OR(NOT b2) AS "f",
|
|
|
|
BOOL_OR(NOT b3) AS "t"
|
|
|
|
FROM bool_test;
|
2005-04-12 01:06:57 +02:00
|
|
|
|
|
|
|
--
|
2010-11-04 17:01:17 +01:00
|
|
|
-- Test cases that should be optimized into indexscans instead of
|
|
|
|
-- the generic aggregate implementation.
|
2005-04-12 01:06:57 +02:00
|
|
|
--
|
|
|
|
|
|
|
|
-- Basic cases
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select min(unique1) from tenk1;
|
|
|
|
select min(unique1) from tenk1;
|
|
|
|
explain (costs off)
|
|
|
|
select max(unique1) from tenk1;
|
2005-04-12 01:06:57 +02:00
|
|
|
select max(unique1) from tenk1;
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select max(unique1) from tenk1 where unique1 < 42;
|
2005-04-12 01:06:57 +02:00
|
|
|
select max(unique1) from tenk1 where unique1 < 42;
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select max(unique1) from tenk1 where unique1 > 42;
|
2005-04-12 01:06:57 +02:00
|
|
|
select max(unique1) from tenk1 where unique1 > 42;
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select max(unique1) from tenk1 where unique1 > 42000;
|
2005-04-12 01:06:57 +02:00
|
|
|
select max(unique1) from tenk1 where unique1 > 42000;
|
|
|
|
|
|
|
|
-- multi-column index (uses tenk1_thous_tenthous)
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select max(tenthous) from tenk1 where thousand = 33;
|
2005-04-12 01:06:57 +02:00
|
|
|
select max(tenthous) from tenk1 where thousand = 33;
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select min(tenthous) from tenk1 where thousand = 33;
|
2005-04-12 01:06:57 +02:00
|
|
|
select min(tenthous) from tenk1 where thousand = 33;
|
|
|
|
|
|
|
|
-- check parameter propagation into an indexscan subquery
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select f1, (select min(unique1) from tenk1 where unique1 > f1) AS gt
|
|
|
|
from int4_tbl;
|
2005-04-12 01:06:57 +02:00
|
|
|
select f1, (select min(unique1) from tenk1 where unique1 > f1) AS gt
|
2010-11-04 17:01:17 +01:00
|
|
|
from int4_tbl;
|
2008-03-31 18:59:26 +02:00
|
|
|
|
|
|
|
-- check some cases that were handled incorrectly in 8.3.0
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select distinct max(unique2) from tenk1;
|
2008-03-31 18:59:26 +02:00
|
|
|
select distinct max(unique2) from tenk1;
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select max(unique2) from tenk1 order by 1;
|
2008-03-31 18:59:26 +02:00
|
|
|
select max(unique2) from tenk1 order by 1;
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select max(unique2) from tenk1 order by max(unique2);
|
2008-03-31 18:59:26 +02:00
|
|
|
select max(unique2) from tenk1 order by max(unique2);
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select max(unique2) from tenk1 order by max(unique2)+1;
|
2008-03-31 18:59:26 +02:00
|
|
|
select max(unique2) from tenk1 order by max(unique2)+1;
|
2010-11-04 17:01:17 +01:00
|
|
|
explain (costs off)
|
|
|
|
select max(unique2), generate_series(1,3) as g from tenk1 order by g desc;
|
2008-03-31 18:59:26 +02:00
|
|
|
select max(unique2), generate_series(1,3) as g from tenk1 order by g desc;
|
2010-11-04 17:01:17 +01:00
|
|
|
|
|
|
|
-- try it on an inheritance tree
|
|
|
|
create table minmaxtest(f1 int);
|
|
|
|
create table minmaxtest1() inherits (minmaxtest);
|
|
|
|
create table minmaxtest2() inherits (minmaxtest);
|
2011-03-22 05:34:31 +01:00
|
|
|
create table minmaxtest3() inherits (minmaxtest);
|
2010-11-04 17:01:17 +01:00
|
|
|
create index minmaxtesti on minmaxtest(f1);
|
|
|
|
create index minmaxtest1i on minmaxtest1(f1);
|
|
|
|
create index minmaxtest2i on minmaxtest2(f1 desc);
|
2011-03-22 05:34:31 +01:00
|
|
|
create index minmaxtest3i on minmaxtest3(f1) where f1 is not null;
|
2010-11-04 17:01:17 +01:00
|
|
|
|
|
|
|
insert into minmaxtest values(11), (12);
|
|
|
|
insert into minmaxtest1 values(13), (14);
|
|
|
|
insert into minmaxtest2 values(15), (16);
|
2011-03-22 05:34:31 +01:00
|
|
|
insert into minmaxtest3 values(17), (18);
|
2010-11-04 17:01:17 +01:00
|
|
|
|
|
|
|
explain (costs off)
|
|
|
|
select min(f1), max(f1) from minmaxtest;
|
|
|
|
select min(f1), max(f1) from minmaxtest;
|
|
|
|
|
2012-11-26 18:57:17 +01:00
|
|
|
-- DISTINCT doesn't do anything useful here, but it shouldn't fail
|
|
|
|
explain (costs off)
|
|
|
|
select distinct min(f1), max(f1) from minmaxtest;
|
|
|
|
select distinct min(f1), max(f1) from minmaxtest;
|
|
|
|
|
2010-11-04 17:01:17 +01:00
|
|
|
drop table minmaxtest cascade;
|
2009-12-15 18:57:48 +01:00
|
|
|
|
Centralize the logic for detecting misplaced aggregates, window funcs, etc.
Formerly we relied on checking after-the-fact to see if an expression
contained aggregates, window functions, or sub-selects when it shouldn't.
This is grotty, easily forgotten (indeed, we had forgotten to teach
DefineIndex about rejecting window functions), and none too efficient
since it requires extra traversals of the parse tree. To improve matters,
define an enum type that classifies all SQL sub-expressions, store it in
ParseState to show what kind of expression we are currently parsing, and
make transformAggregateCall, transformWindowFuncCall, and transformSubLink
check the expression type and throw error if the type indicates the
construct is disallowed. This allows removal of a large number of ad-hoc
checks scattered around the code base. The enum type is sufficiently
fine-grained that we can still produce error messages of at least the
same specificity as before.
Bringing these error checks together revealed that we'd been none too
consistent about phrasing of the error messages, so standardize the wording
a bit.
Also, rewrite checking of aggregate arguments so that it requires only one
traversal of the arguments, rather than up to three as before.
In passing, clean up some more comments left over from add_missing_from
support, and annotate some tests that I think are dead code now that that's
gone. (I didn't risk actually removing said dead code, though.)
2012-08-10 17:35:33 +02:00
|
|
|
-- check for correct detection of nested-aggregate errors
|
|
|
|
select max(min(unique1)) from tenk1;
|
|
|
|
select (select max(min(unique1)) from int8_tbl) from tenk1;
|
|
|
|
|
2016-02-11 23:34:59 +01:00
|
|
|
--
|
|
|
|
-- Test removal of redundant GROUP BY columns
|
|
|
|
--
|
|
|
|
|
|
|
|
create temp table t1 (a int, b int, c int, d int, primary key (a, b));
|
|
|
|
create temp table t2 (x int, y int, z int, primary key (x, y));
|
|
|
|
create temp table t3 (a int, b int, c int, primary key(a, b) deferrable);
|
|
|
|
|
|
|
|
-- Non-primary-key columns can be removed from GROUP BY
|
|
|
|
explain (costs off) select * from t1 group by a,b,c,d;
|
|
|
|
|
|
|
|
-- No removal can happen if the complete PK is not present in GROUP BY
|
|
|
|
explain (costs off) select a,c from t1 group by a,c,d;
|
|
|
|
|
|
|
|
-- Test removal across multiple relations
|
|
|
|
explain (costs off) select *
|
|
|
|
from t1 inner join t2 on t1.a = t2.x and t1.b = t2.y
|
|
|
|
group by t1.a,t1.b,t1.c,t1.d,t2.x,t2.y,t2.z;
|
|
|
|
|
|
|
|
-- Test case where t1 can be optimized but not t2
|
|
|
|
explain (costs off) select t1.*,t2.x,t2.z
|
|
|
|
from t1 inner join t2 on t1.a = t2.x and t1.b = t2.y
|
|
|
|
group by t1.a,t1.b,t1.c,t1.d,t2.x,t2.z;
|
|
|
|
|
|
|
|
-- Cannot optimize when PK is deferrable
|
|
|
|
explain (costs off) select * from t3 group by a,b,c;
|
|
|
|
|
|
|
|
drop table t1;
|
|
|
|
drop table t2;
|
|
|
|
drop table t3;
|
|
|
|
|
2009-12-15 18:57:48 +01:00
|
|
|
--
|
|
|
|
-- Test combinations of DISTINCT and/or ORDER BY
|
|
|
|
--
|
|
|
|
|
|
|
|
select array_agg(a order by b)
|
|
|
|
from (values (1,4),(2,3),(3,1),(4,2)) v(a,b);
|
|
|
|
select array_agg(a order by a)
|
|
|
|
from (values (1,4),(2,3),(3,1),(4,2)) v(a,b);
|
|
|
|
select array_agg(a order by a desc)
|
|
|
|
from (values (1,4),(2,3),(3,1),(4,2)) v(a,b);
|
|
|
|
select array_agg(b order by a desc)
|
|
|
|
from (values (1,4),(2,3),(3,1),(4,2)) v(a,b);
|
|
|
|
|
|
|
|
select array_agg(distinct a)
|
|
|
|
from (values (1),(2),(1),(3),(null),(2)) v(a);
|
|
|
|
select array_agg(distinct a order by a)
|
|
|
|
from (values (1),(2),(1),(3),(null),(2)) v(a);
|
|
|
|
select array_agg(distinct a order by a desc)
|
|
|
|
from (values (1),(2),(1),(3),(null),(2)) v(a);
|
|
|
|
select array_agg(distinct a order by a desc nulls last)
|
|
|
|
from (values (1),(2),(1),(3),(null),(2)) v(a);
|
|
|
|
|
|
|
|
-- multi-arg aggs, strict/nonstrict, distinct/order by
|
|
|
|
|
|
|
|
select aggfstr(a,b,c)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
|
|
|
|
select aggfns(a,b,c)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
|
|
|
|
|
|
|
|
select aggfstr(distinct a,b,c)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,3) i;
|
|
|
|
select aggfns(distinct a,b,c)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,3) i;
|
|
|
|
|
|
|
|
select aggfstr(distinct a,b,c order by b)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,3) i;
|
|
|
|
select aggfns(distinct a,b,c order by b)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,3) i;
|
|
|
|
|
|
|
|
-- test specific code paths
|
|
|
|
|
|
|
|
select aggfns(distinct a,a,c order by c using ~<~,a)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,2) i;
|
|
|
|
select aggfns(distinct a,a,c order by c using ~<~)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,2) i;
|
|
|
|
select aggfns(distinct a,a,c order by a)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,2) i;
|
|
|
|
select aggfns(distinct a,b,c order by a,c using ~<~,b)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,2) i;
|
|
|
|
|
|
|
|
-- check node I/O via view creation and usage, also deparsing logic
|
|
|
|
|
|
|
|
create view agg_view1 as
|
|
|
|
select aggfns(a,b,c)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
|
|
|
|
|
|
|
|
select * from agg_view1;
|
|
|
|
select pg_get_viewdef('agg_view1'::regclass);
|
|
|
|
|
|
|
|
create or replace view agg_view1 as
|
|
|
|
select aggfns(distinct a,b,c)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,3) i;
|
|
|
|
|
|
|
|
select * from agg_view1;
|
|
|
|
select pg_get_viewdef('agg_view1'::regclass);
|
|
|
|
|
|
|
|
create or replace view agg_view1 as
|
|
|
|
select aggfns(distinct a,b,c order by b)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,3) i;
|
|
|
|
|
|
|
|
select * from agg_view1;
|
|
|
|
select pg_get_viewdef('agg_view1'::regclass);
|
|
|
|
|
|
|
|
create or replace view agg_view1 as
|
|
|
|
select aggfns(a,b,c order by b+1)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
|
|
|
|
|
|
|
|
select * from agg_view1;
|
|
|
|
select pg_get_viewdef('agg_view1'::regclass);
|
|
|
|
|
|
|
|
create or replace view agg_view1 as
|
|
|
|
select aggfns(a,a,c order by b)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
|
|
|
|
|
|
|
|
select * from agg_view1;
|
|
|
|
select pg_get_viewdef('agg_view1'::regclass);
|
|
|
|
|
|
|
|
create or replace view agg_view1 as
|
|
|
|
select aggfns(a,b,c order by c using ~<~)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
|
|
|
|
|
|
|
|
select * from agg_view1;
|
|
|
|
select pg_get_viewdef('agg_view1'::regclass);
|
|
|
|
|
|
|
|
create or replace view agg_view1 as
|
|
|
|
select aggfns(distinct a,b,c order by a,c using ~<~,b)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,2) i;
|
|
|
|
|
|
|
|
select * from agg_view1;
|
|
|
|
select pg_get_viewdef('agg_view1'::regclass);
|
|
|
|
|
|
|
|
drop view agg_view1;
|
|
|
|
|
|
|
|
-- incorrect DISTINCT usage errors
|
|
|
|
|
|
|
|
select aggfns(distinct a,b,c order by i)
|
|
|
|
from (values (1,1,'foo')) v(a,b,c), generate_series(1,2) i;
|
|
|
|
select aggfns(distinct a,b,c order by a,b+1)
|
|
|
|
from (values (1,1,'foo')) v(a,b,c), generate_series(1,2) i;
|
|
|
|
select aggfns(distinct a,b,c order by a,b,i,c)
|
|
|
|
from (values (1,1,'foo')) v(a,b,c), generate_series(1,2) i;
|
|
|
|
select aggfns(distinct a,a,c order by a,b)
|
|
|
|
from (values (1,1,'foo')) v(a,b,c), generate_series(1,2) i;
|
2010-02-01 04:14:45 +01:00
|
|
|
|
|
|
|
-- string_agg tests
|
|
|
|
select string_agg(a,',') from (values('aaaa'),('bbbb'),('cccc')) g(a);
|
|
|
|
select string_agg(a,',') from (values('aaaa'),(null),('bbbb'),('cccc')) g(a);
|
2010-08-05 20:21:19 +02:00
|
|
|
select string_agg(a,'AB') from (values(null),(null),('bbbb'),('cccc')) g(a);
|
2010-02-01 04:14:45 +01:00
|
|
|
select string_agg(a,',') from (values(null),(null)) g(a);
|
2010-07-18 21:37:49 +02:00
|
|
|
|
|
|
|
-- check some implicit casting cases, as per bug #5564
|
2010-08-05 20:21:19 +02:00
|
|
|
select string_agg(distinct f1, ',' order by f1) from varchar_tbl; -- ok
|
|
|
|
select string_agg(distinct f1::text, ',' order by f1) from varchar_tbl; -- not ok
|
|
|
|
select string_agg(distinct f1, ',' order by f1::text) from varchar_tbl; -- not ok
|
|
|
|
select string_agg(distinct f1::text, ',' order by f1::text) from varchar_tbl; -- ok
|
2011-12-23 14:40:25 +01:00
|
|
|
|
2012-04-13 20:36:59 +02:00
|
|
|
-- string_agg bytea tests
|
2011-12-23 14:40:25 +01:00
|
|
|
create table bytea_test_table(v bytea);
|
|
|
|
|
2012-04-13 20:36:59 +02:00
|
|
|
select string_agg(v, '') from bytea_test_table;
|
2011-12-23 14:40:25 +01:00
|
|
|
|
|
|
|
insert into bytea_test_table values(decode('ff','hex'));
|
|
|
|
|
2012-04-13 20:36:59 +02:00
|
|
|
select string_agg(v, '') from bytea_test_table;
|
2011-12-23 14:40:25 +01:00
|
|
|
|
|
|
|
insert into bytea_test_table values(decode('aa','hex'));
|
|
|
|
|
2012-04-13 20:36:59 +02:00
|
|
|
select string_agg(v, '') from bytea_test_table;
|
|
|
|
select string_agg(v, NULL) from bytea_test_table;
|
|
|
|
select string_agg(v, decode('ee', 'hex')) from bytea_test_table;
|
2011-12-23 14:40:25 +01:00
|
|
|
|
|
|
|
drop table bytea_test_table;
|
2013-07-17 02:15:36 +02:00
|
|
|
|
|
|
|
-- FILTER tests
|
|
|
|
|
|
|
|
select min(unique1) filter (where unique1 > 100) from tenk1;
|
|
|
|
|
|
|
|
select ten, sum(distinct four) filter (where four::text ~ '123') from onek a
|
|
|
|
group by ten;
|
|
|
|
|
|
|
|
select ten, sum(distinct four) filter (where four > 10) from onek a
|
|
|
|
group by ten
|
|
|
|
having exists (select 1 from onek b where sum(distinct a.four) = b.four);
|
|
|
|
|
|
|
|
select max(foo COLLATE "C") filter (where (bar collate "POSIX") > '0')
|
|
|
|
from (values ('a', 'b')) AS v(foo,bar);
|
|
|
|
|
|
|
|
-- outer reference in FILTER (PostgreSQL extension)
|
|
|
|
select (select count(*)
|
|
|
|
from (values (1)) t0(inner_c))
|
|
|
|
from (values (2),(3)) t1(outer_c); -- inner query is aggregation query
|
|
|
|
select (select count(*) filter (where outer_c <> 0)
|
|
|
|
from (values (1)) t0(inner_c))
|
|
|
|
from (values (2),(3)) t1(outer_c); -- outer query is aggregation query
|
|
|
|
select (select count(inner_c) filter (where outer_c <> 0)
|
|
|
|
from (values (1)) t0(inner_c))
|
|
|
|
from (values (2),(3)) t1(outer_c); -- inner query is aggregation query
|
|
|
|
select
|
|
|
|
(select max((select i.unique2 from tenk1 i where i.unique1 = o.unique1))
|
|
|
|
filter (where o.unique1 < 10))
|
|
|
|
from tenk1 o; -- outer query is aggregation query
|
|
|
|
|
|
|
|
-- subquery in FILTER clause (PostgreSQL extension)
|
|
|
|
select sum(unique1) FILTER (WHERE
|
|
|
|
unique1 IN (SELECT unique1 FROM onek where unique1 < 100)) FROM tenk1;
|
|
|
|
|
|
|
|
-- exercise lots of aggregate parts with FILTER
|
|
|
|
select aggfns(distinct a,b,c order by a,c using ~<~,b) filter (where a > 1)
|
|
|
|
from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
|
|
|
|
generate_series(1,2) i;
|
Allow aggregate functions to be VARIADIC.
There's no inherent reason why an aggregate function can't be variadic
(even VARIADIC ANY) if its transition function can handle the case.
Indeed, this patch to add the feature touches none of the planner or
executor, and little of the parser; the main missing stuff was DDL and
pg_dump support.
It is true that variadic aggregates can create the same sort of ambiguity
about parameters versus ORDER BY keys that was complained of when we
(briefly) had both one- and two-argument forms of string_agg(). However,
the policy formed in response to that discussion only said that we'd not
create any built-in aggregates with varying numbers of arguments, not that
we shouldn't allow users to do it. So the logical extension of that is
we can allow users to make variadic aggregates as long as we're wary about
shipping any such in core.
In passing, this patch allows aggregate function arguments to be named, to
the extent of remembering the names in pg_proc and dumping them in pg_dump.
You can't yet call an aggregate using named-parameter notation. That seems
like a likely future extension, but it'll take some work, and it's not what
this patch is really about. Likewise, there's still some work needed to
make window functions handle VARIADIC fully, but I left that for another
day.
initdb forced because of new aggvariadic field in Aggref parse nodes.
2013-09-03 23:08:38 +02:00
|
|
|
|
Support ordered-set (WITHIN GROUP) aggregates.
This patch introduces generic support for ordered-set and hypothetical-set
aggregate functions, as well as implementations of the instances defined in
SQL:2008 (percentile_cont(), percentile_disc(), rank(), dense_rank(),
percent_rank(), cume_dist()). We also added mode() though it is not in the
spec, as well as versions of percentile_cont() and percentile_disc() that
can compute multiple percentile values in one pass over the data.
Unlike the original submission, this patch puts full control of the sorting
process in the hands of the aggregate's support functions. To allow the
support functions to find out how they're supposed to sort, a new API
function AggGetAggref() is added to nodeAgg.c. This allows retrieval of
the aggregate call's Aggref node, which may have other uses beyond the
immediate need. There is also support for ordered-set aggregates to
install cleanup callback functions, so that they can be sure that
infrastructure such as tuplesort objects gets cleaned up.
In passing, make some fixes in the recently-added support for variadic
aggregates, and make some editorial adjustments in the recent FILTER
additions for aggregates. Also, simplify use of IsBinaryCoercible() by
allowing it to succeed whenever the target type is ANY or ANYELEMENT.
It was inconsistent that it dealt with other polymorphic target types
but not these.
Atri Sharma and Andrew Gierth; reviewed by Pavel Stehule and Vik Fearing,
and rather heavily editorialized upon by Tom Lane
2013-12-23 22:11:35 +01:00
|
|
|
-- ordered-set aggregates
|
|
|
|
|
|
|
|
select p, percentile_cont(p) within group (order by x::float8)
|
|
|
|
from generate_series(1,5) x,
|
|
|
|
(values (0::float8),(0.1),(0.25),(0.4),(0.5),(0.6),(0.75),(0.9),(1)) v(p)
|
|
|
|
group by p order by p;
|
|
|
|
|
|
|
|
select p, percentile_cont(p order by p) within group (order by x) -- error
|
|
|
|
from generate_series(1,5) x,
|
|
|
|
(values (0::float8),(0.1),(0.25),(0.4),(0.5),(0.6),(0.75),(0.9),(1)) v(p)
|
|
|
|
group by p order by p;
|
|
|
|
|
|
|
|
select p, sum() within group (order by x::float8) -- error
|
|
|
|
from generate_series(1,5) x,
|
|
|
|
(values (0::float8),(0.1),(0.25),(0.4),(0.5),(0.6),(0.75),(0.9),(1)) v(p)
|
|
|
|
group by p order by p;
|
|
|
|
|
|
|
|
select p, percentile_cont(p,p) -- error
|
|
|
|
from generate_series(1,5) x,
|
|
|
|
(values (0::float8),(0.1),(0.25),(0.4),(0.5),(0.6),(0.75),(0.9),(1)) v(p)
|
|
|
|
group by p order by p;
|
|
|
|
|
|
|
|
select percentile_cont(0.5) within group (order by b) from aggtest;
|
|
|
|
select percentile_cont(0.5) within group (order by b), sum(b) from aggtest;
|
|
|
|
select percentile_cont(0.5) within group (order by thousand) from tenk1;
|
|
|
|
select percentile_disc(0.5) within group (order by thousand) from tenk1;
|
|
|
|
select rank(3) within group (order by x)
|
|
|
|
from (values (1),(1),(2),(2),(3),(3),(4)) v(x);
|
|
|
|
select cume_dist(3) within group (order by x)
|
|
|
|
from (values (1),(1),(2),(2),(3),(3),(4)) v(x);
|
|
|
|
select percent_rank(3) within group (order by x)
|
|
|
|
from (values (1),(1),(2),(2),(3),(3),(4),(5)) v(x);
|
|
|
|
select dense_rank(3) within group (order by x)
|
|
|
|
from (values (1),(1),(2),(2),(3),(3),(4)) v(x);
|
|
|
|
|
|
|
|
select percentile_disc(array[0,0.1,0.25,0.5,0.75,0.9,1]) within group (order by thousand)
|
|
|
|
from tenk1;
|
|
|
|
select percentile_cont(array[0,0.25,0.5,0.75,1]) within group (order by thousand)
|
|
|
|
from tenk1;
|
|
|
|
select percentile_disc(array[[null,1,0.5],[0.75,0.25,null]]) within group (order by thousand)
|
|
|
|
from tenk1;
|
2014-12-13 17:49:16 +01:00
|
|
|
select percentile_cont(array[0,1,0.25,0.75,0.5,1,0.3,0.32,0.35,0.38,0.4]) within group (order by x)
|
Support ordered-set (WITHIN GROUP) aggregates.
This patch introduces generic support for ordered-set and hypothetical-set
aggregate functions, as well as implementations of the instances defined in
SQL:2008 (percentile_cont(), percentile_disc(), rank(), dense_rank(),
percent_rank(), cume_dist()). We also added mode() though it is not in the
spec, as well as versions of percentile_cont() and percentile_disc() that
can compute multiple percentile values in one pass over the data.
Unlike the original submission, this patch puts full control of the sorting
process in the hands of the aggregate's support functions. To allow the
support functions to find out how they're supposed to sort, a new API
function AggGetAggref() is added to nodeAgg.c. This allows retrieval of
the aggregate call's Aggref node, which may have other uses beyond the
immediate need. There is also support for ordered-set aggregates to
install cleanup callback functions, so that they can be sure that
infrastructure such as tuplesort objects gets cleaned up.
In passing, make some fixes in the recently-added support for variadic
aggregates, and make some editorial adjustments in the recent FILTER
additions for aggregates. Also, simplify use of IsBinaryCoercible() by
allowing it to succeed whenever the target type is ANY or ANYELEMENT.
It was inconsistent that it dealt with other polymorphic target types
but not these.
Atri Sharma and Andrew Gierth; reviewed by Pavel Stehule and Vik Fearing,
and rather heavily editorialized upon by Tom Lane
2013-12-23 22:11:35 +01:00
|
|
|
from generate_series(1,6) x;
|
|
|
|
|
|
|
|
select ten, mode() within group (order by string4) from tenk1 group by ten;
|
|
|
|
|
|
|
|
select percentile_disc(array[0.25,0.5,0.75]) within group (order by x)
|
|
|
|
from unnest('{fred,jim,fred,jack,jill,fred,jill,jim,jim,sheila,jim,sheila}'::text[]) u(x);
|
|
|
|
|
|
|
|
-- check collation propagates up in suitable cases:
|
|
|
|
select pg_collation_for(percentile_disc(1) within group (order by x collate "POSIX"))
|
|
|
|
from (values ('fred'),('jim')) v(x);
|
|
|
|
|
|
|
|
-- ordered-set aggs created with CREATE AGGREGATE
|
|
|
|
select test_rank(3) within group (order by x)
|
|
|
|
from (values (1),(1),(2),(2),(3),(3),(4)) v(x);
|
|
|
|
select test_percentile_disc(0.5) within group (order by thousand) from tenk1;
|
|
|
|
|
|
|
|
-- ordered-set aggs can't use ungrouped vars in direct args:
|
|
|
|
select rank(x) within group (order by x) from generate_series(1,5) x;
|
|
|
|
|
|
|
|
-- outer-level agg can't use a grouped arg of a lower level, either:
|
|
|
|
select array(select percentile_disc(a) within group (order by x)
|
|
|
|
from (values (0.3),(0.7)) v(a) group by a)
|
|
|
|
from generate_series(1,5) g(x);
|
|
|
|
|
|
|
|
-- agg in the direct args is a grouping violation, too:
|
|
|
|
select rank(sum(x)) within group (order by x) from generate_series(1,5) x;
|
|
|
|
|
|
|
|
-- hypothetical-set type unification and argument-count failures:
|
|
|
|
select rank(3) within group (order by x) from (values ('fred'),('jim')) v(x);
|
|
|
|
select rank(3) within group (order by stringu1,stringu2) from tenk1;
|
|
|
|
select rank('fred') within group (order by x) from generate_series(1,5) x;
|
|
|
|
select rank('adam'::text collate "C") within group (order by x collate "POSIX")
|
|
|
|
from (values ('fred'),('jim')) v(x);
|
|
|
|
-- hypothetical-set type unification successes:
|
|
|
|
select rank('adam'::varchar) within group (order by x) from (values ('fred'),('jim')) v(x);
|
|
|
|
select rank('3') within group (order by x) from generate_series(1,5) x;
|
|
|
|
|
|
|
|
-- divide by zero check
|
|
|
|
select percent_rank(0) within group (order by x) from generate_series(1,0) x;
|
|
|
|
|
|
|
|
-- deparse and multiple features:
|
|
|
|
create view aggordview1 as
|
|
|
|
select ten,
|
|
|
|
percentile_disc(0.5) within group (order by thousand) as p50,
|
|
|
|
percentile_disc(0.5) within group (order by thousand) filter (where hundred=1) as px,
|
|
|
|
rank(5,'AZZZZ',50) within group (order by hundred, string4 desc, hundred)
|
|
|
|
from tenk1
|
|
|
|
group by ten order by ten;
|
|
|
|
|
|
|
|
select pg_get_viewdef('aggordview1');
|
|
|
|
select * from aggordview1 order by ten;
|
|
|
|
drop view aggordview1;
|
|
|
|
|
Allow aggregate functions to be VARIADIC.
There's no inherent reason why an aggregate function can't be variadic
(even VARIADIC ANY) if its transition function can handle the case.
Indeed, this patch to add the feature touches none of the planner or
executor, and little of the parser; the main missing stuff was DDL and
pg_dump support.
It is true that variadic aggregates can create the same sort of ambiguity
about parameters versus ORDER BY keys that was complained of when we
(briefly) had both one- and two-argument forms of string_agg(). However,
the policy formed in response to that discussion only said that we'd not
create any built-in aggregates with varying numbers of arguments, not that
we shouldn't allow users to do it. So the logical extension of that is
we can allow users to make variadic aggregates as long as we're wary about
shipping any such in core.
In passing, this patch allows aggregate function arguments to be named, to
the extent of remembering the names in pg_proc and dumping them in pg_dump.
You can't yet call an aggregate using named-parameter notation. That seems
like a likely future extension, but it'll take some work, and it's not what
this patch is really about. Likewise, there's still some work needed to
make window functions handle VARIADIC fully, but I left that for another
day.
initdb forced because of new aggvariadic field in Aggref parse nodes.
2013-09-03 23:08:38 +02:00
|
|
|
-- variadic aggregates
|
|
|
|
select least_agg(q1,q2) from int8_tbl;
|
|
|
|
select least_agg(variadic array[q1,q2]) from int8_tbl;
|
2015-08-04 16:53:10 +02:00
|
|
|
|
|
|
|
|
|
|
|
-- test aggregates with common transition functions share the same states
|
|
|
|
begin work;
|
|
|
|
|
|
|
|
create type avg_state as (total bigint, count bigint);
|
|
|
|
|
|
|
|
create or replace function avg_transfn(state avg_state, n int) returns avg_state as
|
|
|
|
$$
|
|
|
|
declare new_state avg_state;
|
|
|
|
begin
|
|
|
|
raise notice 'avg_transfn called with %', n;
|
|
|
|
if state is null then
|
|
|
|
if n is not null then
|
|
|
|
new_state.total := n;
|
|
|
|
new_state.count := 1;
|
|
|
|
return new_state;
|
|
|
|
end if;
|
|
|
|
return null;
|
|
|
|
elsif n is not null then
|
|
|
|
state.total := state.total + n;
|
|
|
|
state.count := state.count + 1;
|
|
|
|
return state;
|
|
|
|
end if;
|
|
|
|
|
|
|
|
return null;
|
|
|
|
end
|
|
|
|
$$ language plpgsql;
|
|
|
|
|
|
|
|
create function avg_finalfn(state avg_state) returns int4 as
|
|
|
|
$$
|
|
|
|
begin
|
|
|
|
if state is null then
|
|
|
|
return NULL;
|
|
|
|
else
|
|
|
|
return state.total / state.count;
|
|
|
|
end if;
|
|
|
|
end
|
|
|
|
$$ language plpgsql;
|
|
|
|
|
|
|
|
create function sum_finalfn(state avg_state) returns int4 as
|
|
|
|
$$
|
|
|
|
begin
|
|
|
|
if state is null then
|
|
|
|
return NULL;
|
|
|
|
else
|
|
|
|
return state.total;
|
|
|
|
end if;
|
|
|
|
end
|
|
|
|
$$ language plpgsql;
|
|
|
|
|
|
|
|
create aggregate my_avg(int4)
|
|
|
|
(
|
|
|
|
stype = avg_state,
|
|
|
|
sfunc = avg_transfn,
|
|
|
|
finalfunc = avg_finalfn
|
|
|
|
);
|
|
|
|
|
|
|
|
create aggregate my_sum(int4)
|
|
|
|
(
|
|
|
|
stype = avg_state,
|
|
|
|
sfunc = avg_transfn,
|
|
|
|
finalfunc = sum_finalfn
|
|
|
|
);
|
|
|
|
|
|
|
|
-- aggregate state should be shared as aggs are the same.
|
|
|
|
select my_avg(one),my_avg(one) from (values(1),(3)) t(one);
|
|
|
|
|
|
|
|
-- aggregate state should be shared as transfn is the same for both aggs.
|
|
|
|
select my_avg(one),my_sum(one) from (values(1),(3)) t(one);
|
|
|
|
|
|
|
|
-- shouldn't share states due to the distinctness not matching.
|
|
|
|
select my_avg(distinct one),my_sum(one) from (values(1),(3)) t(one);
|
|
|
|
|
|
|
|
-- shouldn't share states due to the filter clause not matching.
|
|
|
|
select my_avg(one) filter (where one > 1),my_sum(one) from (values(1),(3)) t(one);
|
|
|
|
|
|
|
|
-- this should not share the state due to different input columns.
|
|
|
|
select my_avg(one),my_sum(two) from (values(1,2),(3,4)) t(one,two);
|
|
|
|
|
|
|
|
-- test that aggs with the same sfunc and initcond share the same agg state
|
|
|
|
create aggregate my_sum_init(int4)
|
|
|
|
(
|
|
|
|
stype = avg_state,
|
|
|
|
sfunc = avg_transfn,
|
|
|
|
finalfunc = sum_finalfn,
|
|
|
|
initcond = '(10,0)'
|
|
|
|
);
|
|
|
|
|
|
|
|
create aggregate my_avg_init(int4)
|
|
|
|
(
|
|
|
|
stype = avg_state,
|
|
|
|
sfunc = avg_transfn,
|
|
|
|
finalfunc = avg_finalfn,
|
|
|
|
initcond = '(10,0)'
|
|
|
|
);
|
|
|
|
|
|
|
|
create aggregate my_avg_init2(int4)
|
|
|
|
(
|
|
|
|
stype = avg_state,
|
|
|
|
sfunc = avg_transfn,
|
|
|
|
finalfunc = avg_finalfn,
|
|
|
|
initcond = '(4,0)'
|
|
|
|
);
|
|
|
|
|
|
|
|
-- state should be shared if INITCONDs are matching
|
|
|
|
select my_sum_init(one),my_avg_init(one) from (values(1),(3)) t(one);
|
|
|
|
|
|
|
|
-- Varying INITCONDs should cause the states not to be shared.
|
|
|
|
select my_sum_init(one),my_avg_init2(one) from (values(1),(3)) t(one);
|
|
|
|
|
|
|
|
rollback;
|
|
|
|
|
|
|
|
-- test aggregate state sharing to ensure it works if one aggregate has a
|
|
|
|
-- finalfn and the other one has none.
|
|
|
|
begin work;
|
|
|
|
|
|
|
|
create or replace function sum_transfn(state int4, n int4) returns int4 as
|
|
|
|
$$
|
|
|
|
declare new_state int4;
|
|
|
|
begin
|
|
|
|
raise notice 'sum_transfn called with %', n;
|
|
|
|
if state is null then
|
|
|
|
if n is not null then
|
|
|
|
new_state := n;
|
|
|
|
return new_state;
|
|
|
|
end if;
|
|
|
|
return null;
|
|
|
|
elsif n is not null then
|
|
|
|
state := state + n;
|
|
|
|
return state;
|
|
|
|
end if;
|
|
|
|
|
|
|
|
return null;
|
|
|
|
end
|
|
|
|
$$ language plpgsql;
|
|
|
|
|
|
|
|
create function halfsum_finalfn(state int4) returns int4 as
|
|
|
|
$$
|
|
|
|
begin
|
|
|
|
if state is null then
|
|
|
|
return NULL;
|
|
|
|
else
|
|
|
|
return state / 2;
|
|
|
|
end if;
|
|
|
|
end
|
|
|
|
$$ language plpgsql;
|
|
|
|
|
|
|
|
create aggregate my_sum(int4)
|
|
|
|
(
|
|
|
|
stype = int4,
|
|
|
|
sfunc = sum_transfn
|
|
|
|
);
|
|
|
|
|
|
|
|
create aggregate my_half_sum(int4)
|
|
|
|
(
|
|
|
|
stype = int4,
|
|
|
|
sfunc = sum_transfn,
|
|
|
|
finalfunc = halfsum_finalfn
|
|
|
|
);
|
|
|
|
|
|
|
|
-- Agg state should be shared even though my_sum has no finalfn
|
|
|
|
select my_sum(one),my_half_sum(one) from (values(1),(2),(3),(4)) t(one);
|
|
|
|
|
|
|
|
rollback;
|