将查询结果传递给子查询

Question

SELECT alert,  
  (select created_at from alerts 
    WHERE alert = @ALERT ORDER BY created_at desc LIMIT 1) 
      AS latest FROM alerts GROUP BY alert; 

I am having an issue with the above query where I would like to pass in each alert into the subquery so that I have a column called latest which displays the latest alert for each group of alerts. How should I do this?

Answer 1

This is called a correlated subquery. To make it work, you need table aliases:

SELECT a1.alert,  
       (select a2.created_at
        from alerts a2
        WHERE a2.alert = a1.alert
        ORDER BY a2.created_at desc
        LIMIT 1
       )  AS latest
FROM alerts a1
GROUP BY a1.alert; 

Table aliases are a good habit to get into, because they often make the SQL more readable. It is also a good idea to use table aliases with column references, so you easily know where the column is coming from.

EDIT:

If you really want the latest, you can get it by simply doing:

select alert, max(created_at)
from alerts
group by alert;

Answer 2

I would do the following

SELECT 
    alert_group_name, 
    MAX(created_at) AS latest 
FROM 
     alerts A 
GROUP BY 
     alert_group_name; 

Answer 3

If you are trying to get the latest created_at date for each group of alerts, there is a simpler way.

SELECT
    alert,
    max (created_at) AS latest
FROM
    alerts
GROUP BY
    alert;

Answer 4

For a correlated subquery, you need to reference an expression from the outer query.

The best way to do that is to assign an alias to the table on the outer query, and then reference that in the inner query. Best practice is to assign an alias to EVERY table reference, and qualify EVERY column reference.

All that needs to be done to "fix" your query is to replace the reference to " @ALERT " with a reference to the alert column from the table on the outer query.

In our shop, that statement would be formatted something like this:

SELECT a.alert
     , (SELECT l.created_at 
          FROM alerts l
         WHERE l.alert = a.alert 
         ORDER BY l.created_at DESC
         LIMIT 1
       ) AS latest
  FROM alerts a 
 GROUP
    BY a.alert

Not because that's easier to write that way, but more importantly it's easier to read and understand what the statement is doing.

The correlated subquery approach can be efficient for a small number of rows returned (a very restrictive WHERE clause on the outermost query.) But in general, correlated subqueries in the SELECT list can make for a (what we refer to in our shop) an LDQ "light dimming query".

In our shop, if we needed the resultset returned by that query, that statement would likely be rewritten as:

SELECT a.alert
     , MAX(a.created_at) AS latest
  FROM alerts a
 GROUP
    BY a.alert

And we'd definitely have an index defined ON alerts(alert,created_at) (or an index with additional columns after those first two.) size, we

(I don't anticipate any cases where this statement would return a different result.)