# Aggregate Function Basics

Most developers have a workable knowledge of SQL and are quite familiar with the aggregate functions SUM, COUNT, MIN, MAX and such. Yet I still see logic similar to the following in PL/SQL code:

```DECLARE
l_rows   NUMBER;
BEGIN
SELECT COUNT(*)
INTO   l_rows
FROM   some_table
WHERE  some_column = some_value;

dbms_output.put_line ('Rows found: ' || TO_CHAR(l_rows));

EXCEPTION
WHEN NO_DATA_FOUND THEN
dbms_output.put_line ('No rows found');
END;
```

To an experienced Oracle developer the defect is quite clear: the SQL statement will never throw the NO_DATA_FOUND exception. If there are no rows in the table that meet the selection criteria then the COUNT(*) function will return a value 0 and so we will always get back a row from the above query.

However, what happens in other scenarios with other aggregate functions? This post explorers some of the basic aspects of aggregate functions that appear to trip up inexperienced application developers.

For the examples in this post I will use the following table and data:

```CREATE TABLE agg_demo
(id      NUMBER(6)    NOT NULL
,cat     NUMBER(2)    NOT NULL
,val     NUMBER(4)
,ts      TIMESTAMP
)
/

INSERT INTO agg_demo
SELECT ROWNUM AS id
,      MOD(ROWNUM,5) AS cat
,      CASE WHEN TRUNC(ROWNUM/7) = 0
THEN NULL
ELSE TRUNC(ROWNUM/7)
END AS val
FROM   dual
CONNECT BY level <= 100
/

COMMIT
/
```

So, we have a table with:

• 100 rows with a unique ID value
• a CAT column with values that range from 0 to 4
• a VAL column with values in the range of 0 to 14 that also contains NULLs

```SELECT COUNT(*)
FROM   agg_demo
/

COUNT(*)
----------
100
```

The result is quite obvious: we have 100 rows in our table. Adding a WHERE clause that excludes all rows results in the following:

```SELECT COUNT(*)
FROM   agg_demo
WHERE  cat > 20
/

COUNT(*)
----------
0
```

This is the scenario that is similar to the one that I noted at the start of this post. We still get back a result and that result is 0. So, this query will never throw the PL/SQL NO_DATA_FOUND exception. Furthermore, this type of query will never return NULL, i.e. you will always get a value and that value will be an integer of 0 or greater.

When it comes to the COUNT function, there are three common ways that developers use it:

• COUNT(*)
• COUNT(1), or some other literal constant
• COUNT(column)

So, what are the differences in the above:

```SELECT COUNT(*) AS "count_*"
,      COUNT(1) AS "count_1"
,      COUNT(val) AS "count_val"
FROM   agg_demo
/

count_*    count_1  count_val
---------- ---------- ----------
100        100         94
```

We can see that COUNT(*) and COUNT(1) returned the same value, 100. Both of these functions are returning a count of the number of rows. As an aside, I have heard people claim that one approach is more efficient than the other but there’s no truth in these claims.

The COUNT(val) returns a different value than the other two COUNT functions, which highlights an important difference in how the COUNT function works. When the COUNT function is applied to a specific column, or any expression, then NULLs are not included in the counted result. So, the result of 94 is the number of non-NULL VAL entries.

Regardless of the way COUNT is expressed, when the WHERE clause eliminates all rows from the table the various COUNT functions will always return a value of 0:

```SELECT COUNT(*) AS "count_*"
,      COUNT(1) AS "count_1"
,      COUNT(val) AS "count_val"
FROM   agg_demo
WHERE  cat > 20
/

count_*    count_1  count_val
---------- ---------- ----------
0          0          0
```

It’s interesting to note that COUNT(val) will return a value even if all the rows that the function is applied to contain NULL for the VAL column, i.e. we don’t get back NULL:

```SELECT COUNT(*) AS "count_*"
,      COUNT(1) AS "count_1"
,      COUNT(val) AS "count_val"
FROM   agg_demo
WHERE  val IS NULL
/

count_*    count_1  count_val
---------- ---------- ----------
6          6          0
```

The above illustrates that it’s not necessary to include an NVL function around the count of a column in order to force a non-NULL response, as I’ve seen some developers do. For example, the NVL in the following query is unnecessary:

```SELECT NVL(COUNT(val),0) AS "count_val"
FROM   agg_demo
WHERE  val IS NULL
/

count_val
----------
0
```

It’s also important to note that the above is very different to the following query:

```SELECT COUNT(NVL(val,0)) AS "count_val"
FROM   agg_demo
WHERE  val IS NULL
/

count_val
----------
6
```

In the above query, the NVL function is applied prior to the aggregate COUNT function. This means that the COUNT function is not counting 6 NULLs, which it would normally ignore and therefore report a result of 0. Instead it is counting 6 0’s and returns a count of 6.

Now let’s go back a few steps and add a GROUP BY into the query with no WHERE clause:

```SELECT cat
,      COUNT(*) AS "count_*"
,      COUNT(1) AS "count_1"
,      COUNT(val) AS "count_val"
FROM   agg_demo
GROUP  BY
cat
ORDER  BY
cat
/

CAT    count_*    count_1  count_val
---------- ---------- ---------- ----------
0         20         20         19
1         20         20         18
2         20         20         19
3         20         20         19
4         20         20         19
```

Ther’s probably no surprises here, we end up with a count of the rows per CAT for the COUNT(*) and COUNT(1) functions and a count of the non-NULL VAL entries for the COUNT(val) function. Let’s repeat this query with a WHERE clause that eliminates all rows:

```SELECT cat
,      COUNT(*) AS "count_*"
,      COUNT(1) AS "count_1"
,      COUNT(val) AS "count_val"
FROM   agg_demo
WHERE  cat > 20
GROUP  BY
cat
ORDER  BY
cat
/

no rows selected
```

Ah, now that’s different. This time we didn’t get any rows back, not even one indicating that the various counts are 0. This is probably where most developers go wrong in assuming that COUNT(*) can return no rows and therefore could potentially raise a NO_DATA_FOUND exception in PL/SQL. Once GROUP BY is included in the SQL then it is possible for the query to return no rows since all rows from the table can be excluded and therefore there is nothing to perform the GROUP BY on.

So far we’ve been looking at the COUNT function. What about other aggregate functions? Let’s give SUM, MIN and AVG a try.

```SELECT SUM(val) AS sum_val
,      MIN(val) AS min_val
,      AVG(val) AS avg_val
FROM   agg_demo
/

SUM_VAL    MIN_VAL    AVG_VAL
---------- ---------- ----------
679          1 7.22340426
```

Again, probably no surprises here. For the other aggregate functions we have to specify the column (or expression) on which we are operating, i.e. it makes no sense to try to calculate the average of a row, only a given column (or expression) in the row.

However, on closer consideration, this query does highlight an important point with aggregate functions: NULLs are ignored for the purpose of the calculations performed. For most functions and calculations, the inclusion of NULL will result in a NULL answer. This doesn’t apply to aggregate functions. A simple test illustrates the difference:

```SELECT 1 + 2 + NULL AS result
FROM   dual
/

RESULT
----------

WITH vals AS
(SELECT 1    AS val FROM dual UNION ALL
SELECT 2    AS val FROM dual UNION ALL
SELECT NULL AS val FROM dual)
SELECT SUM(val) AS result
FROM   vals
/

RESULT
----------
3
/```

In the above test we added the values 1, 2 and NULL using the addition operator (+) and the result returned was NULL. When we used the SUM aggregate function on the same set of values we got a result of 2. So, aggregate functions ignore NULLs when performing their calculations.

Let’s see what happens when we have a WHERE clause that eliminates all rows:

```SELECT SUM(val) AS sum_val
,      MIN(val) AS min_val
,      AVG(val) AS avg_val
FROM   agg_demo
WHERE  cat > 20
/

SUM_VAL    MIN_VAL    AVG_VAL
---------- ---------- ----------

```

Similar to the COUNT function we get back a result but in this case the results were NULL. This makes sense. COUNT told us that there were no results, i.e. we had a count of 0, so what else should the sum, minimum and average of no values be? However, keep in mind that we did actually get a result so, again, this type of query will not raise a NO_DATA_FOUND exception.

Potentially you may decide that you do not want NULL and instead default to some other value using the NVL function:

```SELECT NVL(SUM(val),0) AS sum_val
,      NVL(MIN(val),0) AS min_val
,      NVL(AVG(val),0) AS avg_val
FROM   agg_demo
WHERE  cat > 20
/

SUM_VAL    MIN_VAL    AVG_VAL
---------- ---------- ----------
0          0          0
```

However, this is definitely incorrect from a mathematical perspective and more than likely to be incorrect from a business logic perspective. In a code review I certainly would be questioning the use of this type of logic very, very closely. As an aside, I find it amusing that something that is definitely incorrect mathematically may only be unlikely to be incorrect from a business perspective.

Going back to the GROUP BY example:

```SELECT cat
,      SUM(val) AS sum_val
,      MIN(val) AS min_val
,      AVG(val) AS avg_val
FROM   agg_demo
GROUP  BY
cat
ORDER  BY
cat
/

CAT    SUM_VAL    MIN_VAL    AVG_VAL
---------- ---------- ---------- ----------
0        141          1 7.42105263
1        130          1 7.22222222
2        133          1          7
3        136          1 7.15789474
4        139          1 7.31578947
```

We get the sum, minimum and average of the VAL column for each CAT value. There’s nothing unusual here. Likewise, when we add a WHERE clause that eliminates all rows from the table we get:

```SELECT cat
,      SUM(val) AS sum_val
,      MIN(val) AS min_val
,      AVG(val) AS avg_val
FROM   agg_demo
WHERE  cat > 20
GROUP  BY
cat
ORDER  BY
cat
/

no rows selected
```

This is the same as for the COUNT function so there should be no surprises here.