Group similar rows and count groups in PostgreSQL - sql

Question

I've got a table like this:
number | info | side
--------------------
1 | foo | a
2 | bar | a
3 | bar | a
4 | baz | a
5 | foo | a
6 | bar | b
7 | bar | b
8 | foo | a
9 | bar | a
10 | baz | a
I'd like to get how many times a bar group/package (e.g. rows 2,3 is a group, rows 6,7 is a group, row 9 is also a group) appears in the info column depending on side. I'm stuck because I don't really know what do google. Whenever I search for something like group rows or merge rows I always end up finding information about the group by feature.
However I think I need some kind of window function.
Here is what I'd like to achieve:
bar_a | bar_b
-------------
2 | 1

Answer 1

Use lag() to determine first rows of groups:
select
number, info, side,
lag(info || side, 1, '') over (order by number) <> info || side as start_of_group
from my_table
order by 1;
number | info | side | start_of_group
--------+------+------+----------------
1 | foo | a | t
2 | bar | a | t
3 | bar | a | f
4 | baz | a | t
5 | foo | a | t
6 | bar | b | t
7 | bar | b | f
8 | foo | a | t
9 | bar | a | t
10 | baz | a | t
(10 rows)
Aggregate and filter the above result to get the desired output:
select concat(info, '_', side) as info_side, count(*)
from (
select
info, side,
lag(info || side, 1, '') over (order by number) <> info || side as start_of_group
from my_table
) s
where info = 'bar' and start_of_group
group by 1
order by 1;
info_side | count
-----------+-------
bar_a | 2
bar_b | 1
(2 rows)

Answer 2

This is a "gaps-and-islands" problem, at its heart, if I understand correct. For this version, the difference of row numbers should work well.
select sum( (side = 'a')::int) as num_a,
sum( (side = 'b')::int) as num_b
from (select info, side, count(*) as cnt
from (select t.*,
row_number() over (order by number) as seqnum,
row_number() over (partition by info, side order by number) as seqnum_bs
from t
) t
where info = 'bar'
group by info, size, (seqnum - seqnum_bs)
) si;

Answer 3

You can make do with a single window function, which should be the fastest option:
SELECT side, count(*) AS count
FROM (
SELECT side, grp
FROM (
SELECT side, number - row_number() OVER (PARTITION BY side ORDER BY number) AS grp
FROM tbl
WHERE info = 'bar'
) sub1
GROUP BY 1, 2
) sub2
GROUP BY 1
ORDER BY 1; -- optional
Or shorter, maybe not faster:
SELECT side, count(DISTINCT grp) AS count
FROM (
SELECT side, number - row_number() OVER (PARTITION BY side ORDER BY number) AS grp
FROM tbl
WHERE info = 'bar'
) sub
GROUP BY 1
ORDER BY 1; -- optional
The "trick" is that adjacent rows forming a group (grp) have consecutive numbers. When subtracting the running count over the partition on side from the running count over all rows (number), members of a "group" get the same grp number.
If there are gaps in your serial column number, which is not the case in your demo but typically there are gaps (and you actually want to ignore such gaps?!), then use row_number() OVER (ORDER BY number) in a subquery instead of just number to close the gaps first:
SELECT side, count(DISTINCT grp) AS count
FROM (
SELECT side, number - row_number() OVER (PARTITION BY side ORDER BY number) AS grp
FROM (SELECT info, side, row_number() OVER (ORDER BY number) AS number FROM tbl) tbl1
WHERE info = 'bar'
) sub2
GROUP BY 1
ORDER BY 1; -- optional
SQL Fiddle (with extended test case)
Related:
Select longest continuous sequence