aggregate

# LogicTest: default parallel-stmts distsql

statement ok
CREATE TABLE kv (
  k INT PRIMARY KEY,
  v INT,
  w INT,
  s STRING
)

# Aggregate functions return NULL if there are no rows.
query IIIIRRRRBBT
SELECT MIN(1), MAX(1), COUNT(1), SUM_INT(1), AVG(1), SUM(1), STDDEV(1), VARIANCE(1), BOOL_AND(true), BOOL_AND(false), XOR_AGG(b'\x01') FROM kv
----
NULL NULL 0 NULL NULL NULL NULL NULL NULL NULL NULL

# Aggregate functions return NULL if there are no rows.
query T
SELECT ARRAY_AGG(1) FROM kv
----
NULL

query IIIIRRRRBBT
SELECT MIN(v), MAX(v), COUNT(v), SUM_INT(1), AVG(v), SUM(v), STDDEV(v), VARIANCE(v), BOOL_AND(v = 1), BOOL_AND(v = 1), XOR_AGG(s::bytes) FROM kv
----
NULL NULL 0 NULL NULL NULL NULL NULL NULL NULL NULL

query T
SELECT ARRAY_AGG(v) FROM kv
----
NULL

# Aggregate functions triggers aggregation and computation when there is no source.
query IIIIRRRRBBT
SELECT MIN(1), COUNT(1), MAX(1), SUM_INT(1), AVG(1)::float, SUM(1), STDDEV(1), VARIANCE(1), BOOL_AND(true), BOOL_OR(true), TO_HEX(XOR_AGG(b'\x01'))
----
1 1 1 1 1 1 NULL NULL true true 01

# Aggregate functions triggers aggregation and computation when there is no source.
query T
SELECT ARRAY_AGG(1)
----
{1}

# Check that COALESCE using aggregate results over an empty table
# work properly.
query I
SELECT COALESCE(MAX(1), 0) FROM generate_series(1,0)
----
0

query I
SELECT COUNT_ROWS() FROM generate_series(1,100)
----
100

# Same, using arithmetic on COUNT.
query I
SELECT 1 + COUNT(*) FROM generate_series(1,0)
----
1

# Same, using an empty table.
# The following test *must* occur before the first INSERT to the tables,
# so that it can observe an empty table.
query II
SELECT COUNT(*), COALESCE(MAX(k), 1) FROM kv
----
0 1

# Same, using a subquery. (#12705)
query I
SELECT (SELECT COALESCE(MAX(1), 0) FROM generate_series(1,0))
----
0

statement OK
INSERT INTO kv VALUES
(1, 2, 3, 'a'),
(3, 4, 5, 'a'),
(5, NULL, 5, NULL),
(6, 2, 3, 'b'),
(7, 2, 2, 'b'),
(8, 4, 2, 'A')

# Aggregate functions triggers aggregation and computation for every row even when applied to a constant.
# NB: The XOR result is 00 because \x01 is XOR'd an even number of times.
query IIIIRRRRBBT
SELECT MIN(1), COUNT(1), MAX(1), SUM_INT(1), AVG(1)::float, SUM(1), STDDEV(1), VARIANCE(1)::float, BOOL_AND(true), BOOL_OR(true), TO_HEX(XOR_AGG(b'\x01')) FROM kv
----
1 6 1 6 1 6 0 0 true true 00

# Aggregate functions triggers aggregation and computation for every row even when applied to a constant.
query T
SELECT ARRAY_AGG(1) FROM kv
----
{1,1,1,1,1,1}

# Even with no aggregate functions, grouping occurs in the presence of GROUP BY.
query I rowsort
SELECT 1 FROM kv GROUP BY v
----
1
1
1

# Presence of HAVING triggers aggregation, reducing results to one row (even without GROUP BY).
query I rowsort
SELECT 3 FROM kv HAVING TRUE
----
3

query error column "k" must appear in the GROUP BY clause or be used in an aggregate function
SELECT COUNT(*), k FROM kv

query error unsupported comparison operator: <string> < <int>
SELECT COUNT(*) FROM kv GROUP BY s < 5

query II rowsort
SELECT COUNT(*), k FROM kv GROUP BY k
----
1 1
1 3
1 5
1 6
1 7
1 8

# GROUP BY specified using column index works.
query II rowsort
SELECT COUNT(*), k FROM kv GROUP BY 2
----
1 1
1 3
1 5
1 6
1 7
1 8

query error aggregate functions are not allowed in GROUP BY
SELECT * FROM kv GROUP BY v, COUNT(DISTINCT w)

query error aggregate functions are not allowed in GROUP BY
SELECT COUNT(DISTINCT w) FROM kv GROUP BY 1

query error aggregate functions are not allowed in RETURNING
INSERT INTO kv (k, v) VALUES (99, 100) RETURNING sum(v)

query error aggregate functions are not allowed in LIMIT
SELECT SUM(v) FROM kv GROUP BY k LIMIT SUM(v)

query error aggregate functions are not allowed in OFFSET
SELECT SUM(v) FROM kv GROUP BY k LIMIT 1 OFFSET SUM(v)

query error aggregate functions are not allowed in VALUES
INSERT INTO kv (k, v) VALUES (99, COUNT(1))

query error GROUP BY position 5 is not in select list
SELECT COUNT(*), k FROM kv GROUP BY 5

query error GROUP BY position 0 is not in select list
SELECT COUNT(*), k FROM kv GROUP BY 0

query error non-integer constant in GROUP BY
SELECT 1 GROUP BY 'a'

# Qualifying a name in the SELECT, the GROUP BY, both or neither should not affect validation.
query IT rowsort
SELECT COUNT(*), kv.s FROM kv GROUP BY s
----
1 A
1 NULL
2 a
2 b

query IT rowsort
SELECT COUNT(*), s FROM kv GROUP BY kv.s
----
1 A
1 NULL
2 a
2 b

query IT rowsort
SELECT COUNT(*), kv.s FROM kv GROUP BY kv.s
----
1 A
1 NULL
2 a
2 b

query IT rowsort
SELECT COUNT(*), s FROM kv GROUP BY s
----
1 A
1 NULL
2 a
2 b

# Grouping by more than one column works.
query III rowsort
SELECT v, COUNT(*), w FROM kv GROUP BY v, w
----
2    1 2
2    2 3
4    1 2
4    1 5
NULL 1 5

# Grouping by more than one column using column numbers works.
query III rowsort
SELECT v, COUNT(*), w FROM kv GROUP BY 1, 3
----
2    1 2
2    2 3
4    1 2
4    1 5
NULL 1 5

# Selecting and grouping on a function expression works.
query IT rowsort
SELECT COUNT(*), UPPER(s) FROM kv GROUP BY UPPER(s)
----
1 NULL
2 B
3 A

# Selecting and grouping on a constant works.
query I
SELECT COUNT(*) FROM kv GROUP BY 1+2
----
6

query I
SELECT COUNT(*) FROM kv GROUP BY length('abc')
----
6

# Selecting a function of something which is grouped works.
query IT rowsort
SELECT COUNT(*), UPPER(s) FROM kv GROUP BY s
----
1 A
1 NULL
2 A
2 B

# Selecting a value that is not grouped, even if a function of it it, does not work.
query error column "s" must appear in the GROUP BY clause or be used in an aggregate function
SELECT COUNT(*), s FROM kv GROUP BY UPPER(s)

# Selecting and grouping on a more complex expression works.
query ITTTTT
EXPLAIN (VERBOSE) SELECT COUNT(*), k+v FROM kv GROUP BY k+v
----
0  group    (empty)      (empty)                ("count(*)", "k + v")           (empty)  
0  (empty)  aggregate 0  count_rows()           (empty)                         (empty)  
0  (empty)  aggregate 1  test.kv.k + test.kv.v  (empty)                         (empty)  
1  render   (empty)      (empty)                ("k + v")                       (empty)  
1  (empty)  render 0     test.kv.k + test.kv.v  (empty)                         (empty)  
2  scan     (empty)      (empty)                (k, v, w[omitted], s[omitted])  (empty)  
2  (empty)  table        kv@primary             (empty)                         (empty)  
2  (empty)  spans        ALL                    (empty)                         (empty)  

query II rowsort
SELECT COUNT(*), k+v FROM kv GROUP BY k+v
----
1 12
1 3
1 7
1 8
1 9
1 NULL


# Selecting a more complex expression, made up of things which are each grouped, works.
query ITTTTT
EXPLAIN (VERBOSE) SELECT COUNT(*), k+v FROM kv GROUP BY k, v
----
0  render   (empty)      (empty)       ("count(*)", "k + v")           (empty)  
0  (empty)  render 0     "count(*)"    (empty)                         (empty)  
0  (empty)  render 1     k + v         (empty)                         (empty)  
1  group    (empty)      (empty)       ("count(*)", k, v)              (empty)  
1  (empty)  aggregate 0  count_rows()  (empty)                         (empty)  
1  (empty)  aggregate 1  test.kv.k     (empty)                         (empty)  
1  (empty)  aggregate 2  test.kv.v     (empty)                         (empty)  
2  render   (empty)      (empty)       (k, v)                          (empty)  
2  (empty)  render 0     test.kv.k     (empty)                         (empty)  
2  (empty)  render 1     test.kv.v     (empty)                         (empty)  
3  scan     (empty)      (empty)       (k, v, w[omitted], s[omitted])  (empty)  
3  (empty)  table        kv@primary    (empty)                         (empty)  
3  (empty)  spans        ALL           (empty)                         (empty)  

query II rowsort
SELECT COUNT(*), k+v FROM kv GROUP BY k, v
----
1 12
1 3
1 7
1 8
1 9
1 NULL

query error column "v" must appear in the GROUP BY clause or be used in an aggregate function
SELECT COUNT(*), k+v FROM kv GROUP BY k

query error column "k" must appear in the GROUP BY clause or be used in an aggregate function
SELECT COUNT(*), k+v FROM kv GROUP BY v

query error column "v" must appear in the GROUP BY clause or be used in an aggregate function
SELECT COUNT(*), v/(k+v) FROM kv GROUP BY k+v

query error aggregate functions are not allowed in WHERE
SELECT k FROM kv WHERE AVG(k) > 1

query error aggregate functions are not allowed in the argument of max()
SELECT MAX(AVG(k)) FROM kv

# Test case from #2761.
query II rowsort
SELECT count(kv.k) AS count_1, kv.v + kv.w AS lx FROM kv GROUP BY kv.v + kv.w
----
1  4
1  6
1  9
1  NULL
2  5

query TI rowsort
SELECT s, COUNT(*) FROM kv GROUP BY s HAVING COUNT(*) > 1
----
a 2
b 2

query TII rowsort
SELECT UPPER(s), COUNT(DISTINCT s), COUNT(DISTINCT UPPER(s)) FROM kv GROUP BY UPPER(s) HAVING COUNT(DISTINCT s) > 1
----
A 2 1

query II rowsort
SELECT MAX(k), MIN(v) FROM kv HAVING MIN(v) > 2
----

query II rowsort
SELECT MAX(k), MIN(v) FROM kv HAVING MAX(v) > 2
----
8 2

query error aggregate functions are not allowed in the argument of max()
SELECT MAX(k), MIN(v) FROM kv HAVING MAX(MIN(v)) > 2

query error argument of HAVING must be type bool, not type int
SELECT MAX(k), MIN(v) FROM kv HAVING k

# Expressions listed in the HAVING clause must conform to same validation as the SELECT clause (grouped or aggregated).
query error column "k" must appear in the GROUP BY clause or be used in an aggregate function
SELECT 3 FROM kv GROUP BY v HAVING k > 5

# pg has a special case for grouping on primary key, which would allow this, but we do not.
# See http://www.postgresql.org/docs/current/static/sql-select.html#SQL-GROUPBY
query error column "v" must appear in the GROUP BY clause or be used in an aggregate function
SELECT 3 FROM kv GROUP BY k HAVING v > 2

query error column "k" must appear in the GROUP BY clause or be used in an aggregate function
SELECT k FROM kv HAVING k > 7

query error syntax error at or near ","
SELECT COUNT(*, 1) FROM kv

query I
SELECT COUNT(*)
----
1

query I
SELECT COUNT(k) from kv
----
6

query I
SELECT COUNT(1)
----
1

query I
SELECT COUNT(1) from kv
----
6

query error unknown signature: count\(int, int\)
SELECT COUNT(k, v) FROM kv

query II
SELECT v, COUNT(k) FROM kv GROUP BY v ORDER BY v
----
NULL 1
2 3
4 2

query II
SELECT v, COUNT(k) FROM kv GROUP BY v ORDER BY v DESC
----
4 2
2 3
NULL 1

query II
SELECT v, COUNT(k) FROM kv GROUP BY v ORDER BY COUNT(k) DESC
----
2 3
4 2
NULL 1

query II
SELECT v, COUNT(k) FROM kv GROUP BY v ORDER BY v-COUNT(k)
----
NULL 1
2 3
4 2

query II
SELECT v, COUNT(k) FROM kv GROUP BY v ORDER BY 1 DESC
----
4 2
2 3
NULL 1

query III colnames
SELECT COUNT(*), COUNT(k), COUNT(kv.v) FROM kv
----
count(*)  count(k)  count(kv.v)
6         6         5

query error cannot use "kv\.\*" in this context
SELECT COUNT(kv.*) FROM kv

query III
SELECT COUNT(DISTINCT k), COUNT(DISTINCT v), COUNT(DISTINCT (v)) FROM kv
----
6 2 2

query TIII rowsort
SELECT UPPER(s), COUNT(DISTINCT k), COUNT(DISTINCT v), COUNT(DISTINCT (v)) FROM kv GROUP BY UPPER(s)
----
A    3 2 2
B    2 1 1
NULL 1 0 0


query I
SELECT COUNT((k, v)) FROM kv
----
6

query I
SELECT COUNT(DISTINCT (k, v)) FROM kv
----
6

query I
SELECT COUNT(DISTINCT (k, (v))) FROM kv
----
6

query I
SELECT COUNT((k, v)) FROM kv LIMIT 1
----
6

query I
SELECT COUNT((k, v)) FROM kv OFFSET 1
----

query I
SELECT COUNT(k)+COUNT(kv.v) FROM kv
----
11

query II
SELECT COUNT(NULL::int), COUNT((NULL, NULL))
----
0 1

query IIII
SELECT MIN(k), MAX(k), MIN(v), MAX(v) FROM kv
----
1 8 2 4

# Even if no input rows match, we expect a row (of nulls).
query IIII
SELECT MIN(k), MAX(k), MIN(v), MAX(v) FROM kv WHERE k > 8
----
NULL NULL NULL NULL

query TT
SELECT ARRAY_AGG(k), ARRAY_AGG(s) FROM kv
----
{1,3,5,6,7,8} {"a","a",NULL,"b","b","A"}

query T
SELECT array_agg(s) FROM kv WHERE s IS NULL
----
{NULL}

query RRRR
SELECT AVG(k), AVG(v), SUM(k), SUM(v) FROM kv
----
5 2.8 30 14

query RRRR
SELECT AVG(k::decimal), AVG(v::decimal), SUM(k::decimal), SUM(v::decimal) FROM kv
----
5 2.8 30 14

query RRRR
SELECT AVG(DISTINCT k), AVG(DISTINCT v), SUM(DISTINCT k), SUM(DISTINCT v) FROM kv
----
5 3 30 6

query R
SELECT AVG(k) * 2.0 + MAX(v)::DECIMAL FROM kv
----
14.0

# Verify things work with distsql when some of the nodes emit no results in the
# local stage.
query R
SELECT AVG(k) * 2.0 + MAX(v)::DECIMAL FROM kv WHERE w*2 = k
----
14.0

query ITTT
EXPLAIN (EXPRS) SELECT COUNT(k) FROM kv
----
0  group    (empty)      (empty)     
0  (empty)  aggregate 0  count(k)    
1  render   (empty)      (empty)     
1  (empty)  render 0     k           
2  scan     (empty)      (empty)     
2  (empty)  table        kv@primary  
2  (empty)  spans        ALL         

query ITTT
EXPLAIN (EXPRS) SELECT COUNT(k), SUM(k), MAX(k) FROM kv
----
0  group    (empty)      (empty)     
0  (empty)  aggregate 0  count(k)    
0  (empty)  aggregate 1  sum(k)      
0  (empty)  aggregate 2  max(k)      
1  render   (empty)      (empty)     
1  (empty)  render 0     k           
2  scan     (empty)      (empty)     
2  (empty)  table        kv@primary  
2  (empty)  spans        ALL         

statement ok
CREATE TABLE abc (
  a CHAR PRIMARY KEY,
  b FLOAT,
  c BOOLEAN,
  d DECIMAL
)

statement ok
INSERT INTO abc VALUES ('one', 1.5, true, 5::decimal), ('two', 2.0, false, 1.1::decimal)

query ITTT
EXPLAIN (EXPRS) SELECT MIN(a) FROM abc
----
0  group    (empty)      (empty)      
0  (empty)  aggregate 0  min(a)       
1  render   (empty)      (empty)      
1  (empty)  render 0     a            
2  scan     (empty)      (empty)      
2  (empty)  table        abc@primary  
2  (empty)  spans        /#-          
2  (empty)  limit        1            

query TRBR
SELECT MIN(a), MIN(b), MIN(c), MIN(d) FROM abc
----
one 1.5 false 1.1

query TRBR
SELECT MAX(a), MAX(b), MAX(c), MAX(d) FROM abc
----
two 2 true 5

query RRRR
SELECT AVG(b), SUM(b), AVG(d), SUM(d) FROM abc
----
1.75 3.5 3.05 6.1

# Verify summing of intervals
statement ok
CREATE TABLE intervals (
  a INTERVAL PRIMARY KEY
)

statement ok
INSERT INTO intervals VALUES (INTERVAL '1 year 2 months 3 days 4 seconds'), (INTERVAL '2 year 3 months 4 days 5 seconds'), (INTERVAL '10000ms')

query T
SELECT SUM(a) FROM intervals
----
3y5mon7d19s


query error unknown signature: avg\(string\)
SELECT AVG(a) FROM abc

query error unknown signature: avg\(bool\)
SELECT AVG(c) FROM abc

query error unknown signature: avg\(tuple{string, bool}\)
SELECT AVG((a,c)) FROM abc

query error unknown signature: sum\(string\)
SELECT SUM(a) FROM abc

query error unknown signature: sum\(bool\)
SELECT SUM(c) FROM abc

query error unknown signature: sum\(tuple{string, bool}\)
SELECT SUM((a,c)) FROM abc

statement ok
CREATE TABLE xyz (
  x INT PRIMARY KEY,
  y INT,
  z FLOAT,
  INDEX xy (x, y),
  INDEX zyx (z, y, x),
  FAMILY (x),
  FAMILY (y),
  FAMILY (z)
)

statement ok
INSERT INTO xyz VALUES (1, 2, 3.0), (4, 5, 6.0), (7, NULL, 8.0)

query I
SELECT MIN(x) FROM xyz
----
1

query ITTT
EXPLAIN (EXPRS) SELECT MIN(x) FROM xyz
----
0  group    (empty)      (empty)  
0  (empty)  aggregate 0  min(x)   
1  render   (empty)      (empty)  
1  (empty)  render 0     x        
2  scan     (empty)      (empty)  
2  (empty)  table        xyz@xy   
2  (empty)  spans        /#-      
2  (empty)  limit        1        

query I
SELECT MIN(x) FROM xyz WHERE x in (0, 4, 7)
----
4

query ITTT
EXPLAIN (EXPRS) SELECT MIN(x) FROM xyz WHERE x in (0, 4, 7)
----
0  group    (empty)      (empty)            
0  (empty)  aggregate 0  min(x)             
1  render   (empty)      (empty)            
1  (empty)  render 0     x                  
2  scan     (empty)      (empty)            
2  (empty)  table        xyz@xy             
2  (empty)  spans        /0-/1 /4-/5 /7-/8  
2  (empty)  limit        1                  

query I
SELECT MAX(x) FROM xyz
----
7

query ITTT
EXPLAIN (EXPRS) SELECT MAX(x) FROM xyz
----
0  group    (empty)      (empty)  
0  (empty)  aggregate 0  max(x)   
1  render   (empty)      (empty)  
1  (empty)  render 0     x        
2  revscan  (empty)      (empty)  
2  (empty)  table        xyz@xy   
2  (empty)  spans        /#-      
2  (empty)  limit        1        

query I
SELECT MIN(y) FROM xyz WHERE x = 1
----
2

query ITTT
EXPLAIN (EXPRS) SELECT MIN(y) FROM xyz WHERE x = 1
----
0  group    (empty)      (empty)  
0  (empty)  aggregate 0  min(y)   
1  render   (empty)      (empty)  
1  (empty)  render 0     y        
2  scan     (empty)      (empty)  
2  (empty)  table        xyz@xy   
2  (empty)  spans        /1/#-/2  
2  (empty)  limit        1        

query I
SELECT MAX(y) FROM xyz WHERE x = 1
----
2

query ITTT
EXPLAIN (EXPRS) SELECT MAX(y) FROM xyz WHERE x = 1
----
0  group    (empty)      (empty)  
0  (empty)  aggregate 0  max(y)   
1  render   (empty)      (empty)  
1  (empty)  render 0     y        
2  revscan  (empty)      (empty)  
2  (empty)  table        xyz@xy   
2  (empty)  spans        /1/#-/2  
2  (empty)  limit        1        

query I
SELECT MIN(y) FROM xyz WHERE x = 7
----
NULL

query ITTT
EXPLAIN (EXPRS) SELECT MIN(y) FROM xyz WHERE x = 7
----
0  group    (empty)      (empty)  
0  (empty)  aggregate 0  min(y)   
1  render   (empty)      (empty)  
1  (empty)  render 0     y        
2  scan     (empty)      (empty)  
2  (empty)  table        xyz@xy   
2  (empty)  spans        /7/#-/8  
2  (empty)  limit        1        

query I
SELECT MAX(y) FROM xyz WHERE x = 7
----
NULL

query ITTT
EXPLAIN (EXPRS) SELECT MAX(y) FROM xyz WHERE x = 7
----
0  group    (empty)      (empty)  
0  (empty)  aggregate 0  max(y)   
1  render   (empty)      (empty)  
1  (empty)  render 0     y        
2  revscan  (empty)      (empty)  
2  (empty)  table        xyz@xy   
2  (empty)  spans        /7/#-/8  
2  (empty)  limit        1        

query I
SELECT MIN(x) FROM xyz WHERE (y, z) = (2, 3.0)
----
1

query ITTT
EXPLAIN (EXPRS) SELECT MIN(x) FROM xyz WHERE (y, z) = (2, 3.0)
----
0  group    (empty)      (empty)      
0  (empty)  aggregate 0  min(x)       
1  render   (empty)      (empty)      
1  (empty)  render 0     x            
2  scan     (empty)      (empty)      
2  (empty)  table        xyz@zyx      
2  (empty)  spans        /3/2/#-/3/3  
2  (empty)  limit        1            

query T
SELECT message FROM [SHOW KV TRACE FOR SELECT MIN(x) FROM xyz WHERE (y, z) = (2, 3.0)]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
fetched: /xyz/zyx/3.0/2/1 -> NULL
output row: [1]

query I
SELECT MAX(x) FROM xyz WHERE (z, y) = (3.0, 2)
----
1

query ITTT
EXPLAIN (EXPRS) SELECT MAX(x) FROM xyz WHERE (z, y) = (3.0, 2)
----
0  group    (empty)      (empty)      
0  (empty)  aggregate 0  max(x)       
1  render   (empty)      (empty)      
1  (empty)  render 0     x            
2  revscan  (empty)      (empty)      
2  (empty)  table        xyz@zyx      
2  (empty)  spans        /3/2/#-/3/3  
2  (empty)  limit        1            

query RRR
SELECT VARIANCE(x), VARIANCE(y::decimal), round(VARIANCE(z), 14) FROM xyz
----
9 4.5 6.33333333333333

query T
SELECT message FROM [SHOW KV TRACE FOR SELECT VARIANCE(x), VARIANCE(y::decimal), round(VARIANCE(z), 14) FROM xyz]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
fetched: /xyz/primary/1 -> NULL
fetched: /xyz/primary/1/y -> 2
fetched: /xyz/primary/1/z -> 3.0
fetched: /xyz/primary/4 -> NULL
fetched: /xyz/primary/4/y -> 5
fetched: /xyz/primary/4/z -> 6.0
fetched: /xyz/primary/7 -> NULL
fetched: /xyz/primary/7/z -> 8.0
output row: [9 4.5 6.33333333333333]

query R
SELECT VARIANCE(x) FROM xyz WHERE x = 10
----
NULL

query R
SELECT VARIANCE(x) FROM xyz WHERE x = 1
----
NULL

query ITTT
EXPLAIN (EXPRS) SELECT VARIANCE(x) FROM xyz WHERE x = 1
----
0  group    (empty)      (empty)      
0  (empty)  aggregate 0  variance(x)  
1  render   (empty)      (empty)      
1  (empty)  render 0     x            
2  scan     (empty)      (empty)      
2  (empty)  table        xyz@xy       
2  (empty)  spans        /1-/2        

query RRR
SELECT STDDEV(x), STDDEV(y::decimal), round(STDDEV(z), 14) FROM xyz
----
3  2.1213203435596425732  2.51661147842358

query R
SELECT STDDEV(x) FROM xyz WHERE x = 1
----
NULL

# Verify we only look at one row for MIN when we have an index on that column.
query T
SELECT message FROM [SHOW KV TRACE FOR SELECT MIN(z) FROM xyz]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
fetched: /xyz/zyx/3.0/2/1 -> NULL
output row: [3.0]

query RRR
SELECT AVG(1::int)::float, AVG(2::float)::float, AVG(3::decimal)::float
----
1 2 3

query III
SELECT COUNT(2::int), COUNT(3::float), COUNT(4::decimal)
----
1 1 1

query RRR
SELECT SUM(1::int), SUM(2::float), SUM(3::decimal)
----
1 2 3

query RRR
SELECT VARIANCE(1::int), VARIANCE(1::float), VARIANCE(1::decimal)
----
NULL NULL NULL

query RRR
SELECT STDDEV(1::int), STDDEV(1::float), STDDEV(1::decimal)
----
NULL NULL NULL

# Ensure subqueries don't trigger aggregation.
query B
SELECT x > (SELECT avg(0)) FROM xyz LIMIT 1
----
true

statement ok
CREATE TABLE bools (b BOOL)

query BB
SELECT BOOL_AND(b), BOOL_OR(b) FROM bools
----
NULL NULL

statement OK
INSERT INTO bools VALUES (true), (true), (true)

query BB
SELECT BOOL_AND(b), BOOL_OR(b) FROM bools
----
true true

statement OK
INSERT INTO bools VALUES (false), (false)

query BB
SELECT BOOL_AND(b), BOOL_OR(b) FROM bools
----
false true

statement OK
DELETE FROM bools WHERE b

query BB
SELECT BOOL_AND(b), BOOL_OR(b) FROM bools
----
false false

query T
SELECT CONCAT_AGG(s) FROM (SELECT s FROM kv ORDER BY k)
----
aabbA

# Tests for the single-row optimization.
statement OK
CREATE TABLE ab (
  a INT PRIMARY KEY,
  b INT,
  FAMILY (a),
  FAMILY (b)
)

statement OK
INSERT INTO ab VALUES
  (1, 10),
  (2, 20),
  (3, 30),
  (4, 40),
  (5, 50)

query ITTT
EXPLAIN (EXPRS) SELECT MIN(a) FROM abc
----
0  group    (empty)      (empty)      
0  (empty)  aggregate 0  min(a)       
1  render   (empty)      (empty)      
1  (empty)  render 0     a            
2  scan     (empty)      (empty)      
2  (empty)  table        abc@primary  
2  (empty)  spans        /#-          
2  (empty)  limit        1            

# Verify we only buffer one row.
query T
SELECT message FROM [SHOW KV TRACE FOR SELECT MIN(a) FROM ab]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
fetched: /ab/primary/1 -> NULL
fetched: /ab/primary/1/b -> 10
output row: [1]

query ITTT
EXPLAIN (EXPRS) SELECT MAX(a) FROM abc
----
0  group    (empty)      (empty)      
0  (empty)  aggregate 0  max(a)       
1  render   (empty)      (empty)      
1  (empty)  render 0     a            
2  revscan  (empty)      (empty)      
2  (empty)  table        abc@primary  
2  (empty)  spans        /#-          
2  (empty)  limit        1            

# Verify we only buffer one row.
query T
SELECT message FROM [SHOW KV TRACE FOR SELECT MAX(a) FROM ab]
 WHERE message LIKE 'fetched:%' OR message LIKE 'output row%'
----
fetched: /ab/primary/5/b -> 50
fetched: /ab/primary/5 -> NULL
output row: [5]

query ITTT
EXPLAIN (EXPRS) SELECT v, COUNT(k) FROM kv GROUP BY v ORDER BY COUNT(k)
----
0  sort     (empty)      (empty)      
0  (empty)  order        +"count(k)"  
1  group    (empty)      (empty)      
1  (empty)  aggregate 0  v            
1  (empty)  aggregate 1  count(k)     
2  render   (empty)      (empty)      
2  (empty)  render 0     v            
2  (empty)  render 1     k            
3  scan     (empty)      (empty)      
3  (empty)  table        kv@primary   
3  (empty)  spans        ALL          

query ITTT
EXPLAIN (EXPRS) SELECT v, COUNT(*) FROM kv GROUP BY v ORDER BY COUNT(*)
----
0  sort     (empty)      (empty)       
0  (empty)  order        +"count(*)"   
1  group    (empty)      (empty)       
1  (empty)  aggregate 0  v             
1  (empty)  aggregate 1  count_rows()  
2  render   (empty)      (empty)       
2  (empty)  render 0     v             
3  scan     (empty)      (empty)       
3  (empty)  table        kv@primary    
3  (empty)  spans        ALL           

query ITTT
EXPLAIN (EXPRS) SELECT v, COUNT(1) FROM kv GROUP BY v ORDER BY COUNT(1)
----
0  sort     (empty)      (empty)      
0  (empty)  order        +"count(1)"  
1  group    (empty)      (empty)      
1  (empty)  aggregate 0  v            
1  (empty)  aggregate 1  count(1)     
2  render   (empty)      (empty)      
2  (empty)  render 0     v            
2  (empty)  render 1     1            
3  scan     (empty)      (empty)      
3  (empty)  table        kv@primary   
3  (empty)  spans        ALL          

# Check that filters propagate through no-op aggregation.
query ITTT
EXPLAIN(EXPRS) SELECT * FROM (SELECT v, COUNT(1) FROM kv GROUP BY v) WHERE v > 10
----
0  group    (empty)      (empty)     
0  (empty)  aggregate 0  v           
0  (empty)  aggregate 1  count(1)    
1  render   (empty)      (empty)     
1  (empty)  render 0     v           
1  (empty)  render 1     1           
2  scan     (empty)      (empty)     
2  (empty)  table        kv@primary  
2  (empty)  spans        ALL         
2  (empty)  filter       v > 10      

# Verify that FILTER works.

statement ok
CREATE TABLE filter_test (
  k INT,
  v INT,
  mark BOOL
)

statement OK
INSERT INTO filter_test VALUES
(1, 2, false),
(3, 4, true),
(5, NULL, true),
(6, 2, true),
(7, 2, true),
(8, 4, true),
(NULL, 4, true)

# FILTER should eliminate some results.
query II rowsort
SELECT v, COUNT(*) FILTER (WHERE k > 5) FROM filter_test GROUP BY v
----
2 2
4 1
NULL 0

# Test multiple filters
query IBIII rowsort
SELECT v, mark, COUNT(*) FILTER (WHERE k > 5), COUNT(*), MAX(k) FILTER (WHERE k < 8) FROM filter_test GROUP BY v, mark
----
2 false 0 1 1
2 true 2 2 7
4 true 1 3 3
NULL true 0 1 5

query error FILTER specified but abs\(\) is not an aggregate function
SELECT k, abs(k) FILTER (WHERE k=1) FROM kv

query error syntax error at or near "filter"
SELECT k FILTER (WHERE k=1) FROM kv GROUP BY k

query error aggregate functions are not allowed in FILTER
SELECT v, COUNT(*) FILTER (WHERE COUNT(*) > 5) FROM filter_test GROUP BY v

# Check that filter expressions are only rendered once.
query ITTT
EXPLAIN (EXPRS) SELECT COUNT(*) FILTER (WHERE k>5), MAX(k>5) FILTER(WHERE k>5) FROM filter_test GROUP BY v
----
0  group    (empty)      (empty)                            
0  (empty)  aggregate 0  count_rows() FILTER (WHERE k > 5)  
0  (empty)  aggregate 1  max(k > 5) FILTER (WHERE k > 5)    
1  render   (empty)      (empty)                            
1  (empty)  render 0     v                                  
1  (empty)  render 1     k > 5                              
2  scan     (empty)      (empty)                            
2  (empty)  table        filter_test@primary                
2  (empty)  spans        ALL                                

query ITTTTT
EXPLAIN (TYPES) SELECT COUNT(*) FILTER (WHERE k > 5) FROM filter_test GROUP BY v
----
0  group    (empty)      (empty)                                                         ("count(*) FILTER (WHERE k > 5)" int)                          (empty)  
0  (empty)  aggregate 0  (count_rows() FILTER (WHERE ((k)[int] > (5)[int])[bool]))[int]  (empty)                                                        (empty)  
1  render   (empty)      (empty)                                                         (v int, "k > 5" bool)                                          (empty)  
1  (empty)  render 0     (v)[int]                                                        (empty)                                                        (empty)  
1  (empty)  render 1     ((k)[int] > (5)[int])[bool]                                     (empty)                                                        (empty)  
2  scan     (empty)      (empty)                                                         (k int, v int, mark[omitted] bool, rowid[hidden,omitted] int)  (empty)  
2  (empty)  table        filter_test@primary                                             (empty)                                                        (empty)  
2  (empty)  spans        ALL                                                             (empty)                                                        (empty)  

# Tests with * inside GROUP BY.
query ITTT
EXPLAIN (EXPRS) SELECT 1 FROM kv GROUP BY kv.*;
----
0  render   (empty)   (empty)     
0  (empty)  render 0  1           
1  group    (empty)   (empty)     
2  scan     (empty)   (empty)     
2  (empty)  table     kv@primary  
2  (empty)  spans     ALL         

query I
SELECT 1 FROM kv GROUP BY kv.*;
----
1
1
1
1
1
1

query ITTT
EXPLAIN (EXPRS) SELECT SUM(abc.d) FROM kv JOIN abc ON kv.k >= abc.d GROUP BY kv.*;
----
0  group    (empty)      (empty)                  
0  (empty)  aggregate 0  sum(d)                   
1  render   (empty)      (empty)                  
1  (empty)  render 0     k                        
1  (empty)  render 1     v                        
1  (empty)  render 2     w                        
1  (empty)  render 3     s                        
1  (empty)  render 4     d                        
2  join     (empty)      (empty)                  
2  (empty)  type         inner                    
2  (empty)  pred         test.kv.k >= test.abc.d  
3  scan     (empty)      (empty)                  
3  (empty)  table        kv@primary               
3  (empty)  spans        ALL                      
3  scan     (empty)      (empty)                  
3  (empty)  table        abc@primary              
3  (empty)  spans        ALL                      

query R rowsort
SELECT SUM(abc.d) FROM kv JOIN abc ON kv.k >= abc.d GROUP BY kv.*;
----
1.1
6.1
6.1
6.1
6.1

# opt_test is used for tests around the single-row optimization for MIN/MAX.
statement ok
CREATE TABLE opt_test (k INT PRIMARY KEY, v INT, INDEX v(v))

statement ok
INSERT INTO opt_test VALUES (1, NULL), (2, 10), (3, NULL), (4, 5)

# Verify that we correctly add the v IS NOT NULL constraint (which restricts the span).
query ITTTTT
EXPLAIN (VERBOSE) SELECT MIN(v) FROM opt_test
----
0  group    (empty)      (empty)               ("min(v)")       (empty)  
0  (empty)  aggregate 0  min(test.opt_test.v)  (empty)          (empty)  
1  render   (empty)      (empty)               (v)              +v       
1  (empty)  render 0     test.opt_test.v       (empty)          (empty)  
2  scan     (empty)      (empty)               (k[omitted], v)  +v       
2  (empty)  table        opt_test@v            (empty)          (empty)  
2  (empty)  spans        /#-                   (empty)          (empty)  
2  (empty)  limit        1                     (empty)          (empty)  

# Without the "v IS NOT NULL" constraint, this result would incorrectly be NULL.
query I
SELECT MIN(v) FROM opt_test
----
5

# Cross-check against a query without this optimization.
query I
SELECT MIN(v) FROM opt_test@primary
----
5

# Repeat test when there is an existing filter.
query ITTTTT
EXPLAIN (VERBOSE) SELECT MIN(v) FROM opt_test WHERE k <> 4
----
0  group    (empty)      (empty)               ("min(v)")  (empty)  
0  (empty)  aggregate 0  min(test.opt_test.v)  (empty)     (empty)  
1  render   (empty)      (empty)               (v)         +v       
1  (empty)  render 0     test.opt_test.v       (empty)     (empty)  
2  scan     (empty)      (empty)               (k, v)      +v       
2  (empty)  table        opt_test@v            (empty)     (empty)  
2  (empty)  spans        /#-                   (empty)     (empty)  
2  (empty)  filter       k != 4                (empty)     (empty)  

query I
SELECT MIN(v) FROM opt_test WHERE k <> 4
----
10

# Check the optimization when the argument is non-trivial. The renderNode can't
# present an ordering on v+1 so the optimization is not applied, but the IS NOT
# NULL filter should be added.
query ITTTTT
EXPLAIN (VERBOSE) SELECT MIN(v+1) FROM opt_test WHERE k <> 4
----
0  group    (empty)      (empty)                             ("min(v + 1)")  (empty)  
0  (empty)  aggregate 0  min(test.opt_test.v + 1)            (empty)         (empty)  
1  render   (empty)      (empty)                             ("v + 1")       (empty)  
1  (empty)  render 0     test.opt_test.v + 1                 (empty)         (empty)  
2  scan     (empty)      (empty)                             (k, v)          (empty)  
2  (empty)  table        opt_test@primary                    (empty)         (empty)  
2  (empty)  spans        /#-                                 (empty)         (empty)  
2  (empty)  filter       (k != 4) AND ((v + 1) IS NOT NULL)  (empty)         (empty)  

# Verify that we don't use the optimization if there is a GROUP BY.
query ITTTTT
EXPLAIN (VERBOSE) SELECT MIN(v) FROM opt_test GROUP BY k
----
0  group    (empty)      (empty)               ("min(v)")  (empty)  
0  (empty)  aggregate 0  min(test.opt_test.v)  (empty)     (empty)  
1  scan     (empty)      (empty)               (k, v)      (empty)  
1  (empty)  table        opt_test@primary      (empty)     (empty)  
1  (empty)  spans        ALL                   (empty)     (empty)  

query I rowsort
SELECT MIN(v) FROM opt_test GROUP BY k
----
NULL
NULL
5
10

query I rowsort
SELECT MAX(v) FROM opt_test GROUP BY k
----
NULL
NULL
5
10

statement ok
CREATE TABLE xor_bytes (a bytes, b int, c int)

statement ok
INSERT INTO xor_bytes VALUES
  (b'\x01\x01', 1, 3),
  (b'\x02\x01', 1, 1),
  (b'\x04\x01', 2, -5),
  (b'\x08\x01', 2, -1),
  (b'\x10\x01', 2, 0)

query TI
SELECT TO_HEX(XOR_AGG(a)), XOR_AGG(c) FROM xor_bytes
----
1f01 6

query TII
SELECT TO_HEX(XOR_AGG(a)), b, XOR_AGG(c) FROM xor_bytes GROUP BY b ORDER BY b
----
0300  1   2
1c01  2   4

statement error arguments to xor must all be the same length
SELECT XOR_AGG(i) FROM (VALUES (b'\x01'), (b'\x01\x01')) AS a(i)

query BB
SELECT MAX(true), MIN(true)
----
true
true