Extremely slow GROUP BY on MySQL. Not index-related - mysql

Question

There are quite a few "why is my GROUP BY so slow" questions on SO, most of them seem to be resolved with indexes.
My situation is different. Indeed I GROUP BY on non-indexed data but this is on purpose and it's not something I can change.
However, when I compare the performance of GROUP BY with the performance of a similar query without a GROUP BY (that also doesn't use indexes) - the GROUP BY query is slower by an order of magnitude.
Slow query:
SELECT someFunc(col), COUNT(*) FROM tbl WHERE col2 = 42 GROUP BY someFunc(col)
The results are something like this:
someFunc(col) COUNT(*)
=========================
a 100000
b 80000
c 20
d 10
Fast(er) query:
SELECT 'a', COUNT(*) FROM tbl WHERE col2 = 42 AND someFunc(col) = 'a'
UNION
SELECT 'b', COUNT(*) FROM tbl WHERE col2 = 42 AND someFunc(col) = 'b'
UNION
SELECT 'c', COUNT(*) FROM tbl WHERE col2 = 42 AND someFunc(col) = 'c'
UNION
SELECT 'd', COUNT(*) FROM tbl WHERE col2 = 42 AND someFunc(col) = 'd'
This query yields the same results and is about ten times faster despite actually running multiple separate queries.
I realize that they are not the same from MySQL point of view, because MySQL doesn't know in advance that someFunc(col) can only yield four different values, but still it seems like too big of a difference.
I'm thinking that this has to do with some work GROUP BY is doing behind the scenes (creating temporary tables and stuff like that).
Are there configuration parameters that I could tweak to make the GROUP BY faster?
Is there a way to hint MySQL to do things differently within the query itself? (e.g. refrain from creating a temporary table).
EDIT:
In fact what I referred to as someFunc(col) above is actually a JSON_EXTRACT(). I just tried to copy the specific data being extracted into its own (unindexed) column and it makes GROUP BY extremely fast, and indeed faster than the alternative UNIONed queries.
The question remains: why? JSON_EXTRACT() might be slow but it should be just as slow with the four queries (in fact slower because more rows are scanned). Also, I've read that MySQL JSON is designed for fast reads.
The difference I'm seeing is between more than 200 seconds (GROUP BY with JSON_EXTRACT()) and 1-2 seconds (GROUP BY on a CONCAT() on an actual unindexed column).

Answer 1

First, for this query:
SELECT someFunc(col), COUNT(*)
FROM tbl
WHERE col2 = 42
GROUP BY someFunc(col);
You should have an index on tbl(col2, col). This is a covering index for the query so it should improve performance.
Small note: The second version should use UNION ALL rather than UNION. The performance difference for eliminating duplicates is small on 4 rows, but UNION is a bad habit in these cases.
I'm not sure what would cause 10x performance slow down. I can readily think of two things that would make the second version faster.
First, this query is calling someFunc() twice for each row being processed. If this is an expensive operation, then that would account for half the increase in query load. This could be much larger if the first version is calling someFunc() on all rows, rather than just on matching rows.
To see if this is an issue, you can try:
SELECT someFunc(col) as someFunc_col, COUNT(*)
FROM tbl
WHERE col2 = 42
GROUP BY someFunc_col;
Second, doing 4 smaller GROUP BYs is going to be a bit faster than doing 1 bigger one. This is because GROUP BY uses a sort, and sorting is O(n log(n)). So, sorting 100,000 rows and 80,000 rows should be faster than sorting 180,000. Your case has about half the data in two groups. This might account for up to 50% difference (although I would be surprised if it were this large).