Last week I was joyfully hacking away at a project, progressing from from one task to another. Then it came time to do a non-trivial SQL query, though at the time I still thought the query would be nothing more than a select with a GROUP BY. I was wrong.

The Problem

What I wanted was to return the most recent log for each task for a particular user.

Here’s my table:

+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+
| log_id | user_id | task_id | when                | duration | description                                                                                            |
+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+
|      1 |       1 |       1 | 0000-00-00 00:00:00 |      120 | getting logging working at a very basic level                                                          |
|      2 |       1 |       1 | 2010-06-26 13:52:49 |       20 | polishing off log insertion                                                                            |
|      3 |       1 |       2 | 2010-06-26 15:00:44 |      120 |                                                                                                        |
|      4 |       1 |       3 | 2010-06-27 14:00:40 |      300 | over 30 serves for school lunches                                                                      |
|      6 |       1 |       4 | 2010-06-28 15:00:51 |      150 | YesMen - WordPress theme                                                                               |
|      7 |       1 |       4 | 2010-06-29 16:30:03 |      240 | on the YesMen WordPress theme                                                                          |
|      8 |       1 |       5 | 2010-06-30 17:32:13 |      240 | Checking out the market, looking at competition and discussions involving successful developers   12pm |
|      9 |       1 |       1 | 2010-06-30 07:00:05 |       40 |                                                                                                        |
+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+

Originally, this was the query that I thought would do it:

SELECT * FROM `logs` WHERE `user_id` = '1' GROUP BY `task_id` ORDER BY `when` DESC;

Which gave me:

+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+
| log_id | user_id | task_id | when                | duration | description                                                                                            |
+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+
|      8 |       1 |       5 | 2010-06-30 17:32:13 |      240 | Checking out the market, looking at competition and discussions involving successful developers   12pm |
|      6 |       1 |       4 | 2010-06-28 15:00:51 |      150 | YesMen - WordPress theme                                                                               |
|      4 |       1 |       3 | 2010-06-27 14:00:40 |      300 | over 30 serves for school lunches                                                                      |
|      3 |       1 |       2 | 2010-06-26 15:00:44 |      120 |                                                                                                        |
|      1 |       1 |       1 | 0000-00-00 00:00:00 |      120 | getting logging working at a very basic level                                                          |
+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+

It looks fine, until you notice task_id 1.

“What?” I thought, “That’s the least recent log for task_id 1!”. Then it struck me, “Oh, ORDER BY is performed after GROUP BY.” (Edit)John Haugeland for bringing up a problem in this post. My expectation of valid results was unfounded because no explicit execution order is defined – it may not always (or ever) produce the correct results. In other words, I shouldn’t have expected it to work. Thanks to commenter

So I thought a bit and said “I know!” and this was my next attempt:

SELECT * FROM `logs` GROUP BY `task_id` HAVING `when` = MAX(`when`);

Which yielded:

+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+
| log_id | user_id | task_id | when                | duration | description                                                                                            |
+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+
|      3 |       1 |       2 | 2010-06-26 15:00:44 |      120 |                                                                                                        |
|      4 |       1 |       3 | 2010-06-27 14:00:40 |      300 | over 30 serves for school lunches                                                                      |
|      8 |       1 |       5 | 2010-06-30 17:32:13 |      240 | Checking out the market, looking at competition and discussions involving successful developers   12pm |
+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+

Though I was hoping that query would do what I wanted, I had a feeling it would do exactly this. It is similar to the last query except it completely removes the logs that aren’t the most recent. This is just as bad. By this point, I had done some searching and even went through my old RMIT Database Concepts Assignments looking for answers. “What now? Will I have to give in and use a subquery? Oh, please no…” As a final resort, I hopped over to #mysql on freenode (I’m SickAnimations).

Somebody linked me to a post about Groupwise Maximum queries on David North’s blog, which was about exactly the same problem as mine. However, the solution there didn’t to work for me – it gave the same results as my second attempt. Knowing the new term “Groupwise Maximum” and how to use The Google, I came across this little nugget on the official MySQL website: 3.6.4. The Rows Holding the Group-wise Maximum of a Certain Column. Jackpot.

The Solution

As I feared, the solution did indeed require a subquery. Here’s my application of MySQL’s suggestion solution:

SELECT *
FROM `logs` outer_logs
WHERE
	`outer_logs`.`user_id` = 1 AND
	`outer_logs`.`when` = (
		SELECT MAX( `inner_logs`.`when` )
		FROM LOGS inner_logs
		WHERE `outer_logs`.`task_id` = `inner_logs`.`task_id`
)

Providing the desired output:

+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+
| log_id | user_id | task_id | when                | duration | description                                                                                            |
+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+
|      3 |       1 |       2 | 2010-06-26 15:00:44 |      120 |                                                                                                        |
|      4 |       1 |       3 | 2010-06-27 14:00:40 |      300 | over 30 serves for school lunches                                                                      |
|      7 |       1 |       4 | 2010-06-29 16:30:03 |      240 | on the YesMen WordPress theme                                                                          |
|      8 |       1 |       5 | 2010-06-30 17:32:13 |      240 | Checking out the market, looking at competition and discussions involving successful developers   12pm |
|     17 |       1 |       1 | 2010-07-08 06:50:39 |       45 | Finalising transition to Linux development environment                                                 |
+--------+---------+---------+---------------------+----------+--------------------------------------------------------------------------------------------------------+

Feels mostly good, except the subquery part. Oh well.

Image from mwin.

Related Posts:

• Lomadaba, The Automatic MySQL Database Dump Backup PHP Script
• Check if Headers Have Already Been Sent in PHP