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
|
|
|
|
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
|
|
|
--
|
2010-11-04 17:01:17 +01:00
|
|
|
analyze tenk1; -- ensure we get consistent plans here
|
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;
|
|
|
|
|
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;
|