ID associated with max date in group - mysql

Question

there are a ton of other related questions but I couldn't quite apply them to my situation. I am using sequelize so I'm trying to do this with as few hits to the DB as possible.
My (simplified) table is basically:
id dateAcquired staffId skillId
44 2017-04-27 25 2
341 2018-02-01 28 2
4787 2018-04-04 25 2
8852 2020-01-31 28 2
I am looking for just the id of the most recent dateAcquired per staffId. (note that the most recent one might be a lower id, otherwise I would have had a solution)
4787
8852
Just in SQL using this query I get the correct date but not the correct id:
SELECT id, staffId, max(`dateAcquired`)
FROM `histories` AS `history`
WHERE `history`.`skillId` = '2'
GROUP BY `staffId`, id
Results in:
44 2018-04-04
341 2020-01-31
Although I know it needs tweaking once I get the query right, my sequelize code is:
models.history.findAll(
{
attributes: [sequelize.fn("max", sequelize.col('dateAcquired')), 'id'],
where: {skillId:id},
group: ["id"]
}
).then(maxIds => {
let ids = maxIds.map(result =>{return result.id;});
models.history.findAll({
include: [
{
model:models.staff
}
],
where: {
id: {
[Op.in]: [ids]
}
}
}).then(results =>
{
res.json(results);
})
})
Thanks for your help!

Answer 1

With NOT EXISTS:
select h.* from histories h
where h.skillid = 2
and not exists (
select 1 from histories
where skillid = h.skillid and staffid = h.staffid and dateAcquired > h.dateAcquired
)
See the demo.
Results:
| id | dateAcquired | staffId | skillId |
| ---- | ------------------- | ------- | ------- |
| 4787 | 2018-04-04 00:00:00 | 25 | 2 |
| 8852 | 2020-01-31 00:00:00 | 28 | 2 |

Answer 2

you can try
Create table #test
(id int,
dateAcquired date,
staffid int,
skillid int
)
Insert into #test values (44 , '2017-04-27' , 25 , 2)
Insert into #test values (341 , '2018-02-01' , 28 , 2)
Insert into #test values (4787 , '2018-04-04' , 25 , 2)
Insert into #test values (8852 , '2020-01-31' , 28 , 2)
select id,dateacquired
from
(
select id,dateacquired,
--ROW_NUMBER()over(partition by dateacquired order by dateacquired )
ROW_NUMBER()over( order by dateacquired desc )rn
from #test
)a where rn<=2

Answer 3

Query
SELECT t.*
FROM my_table t
LEFT JOIN my_table t2 ON t2.staffId = t.staffId AND t2.dateAcquired > t.dateAcquired
WHERE t2.id IS NULL
AND t.skillId = 2;
Explanation
What happens is that each row from t joins onto any rows where the staffId matches and dateAcquired is greater. The only rows that don't join are the ones with the highest values in dateAcquired. We then filter out everything that does join in the WHERE clause.

Answer 4

Several possible query patterns to return the specified result
Using an inline view (derived table) to get the latest (maximum) date_acquired for each staffid, and then a join to the base table to get the row(s) that have that latest date_acquired.
SELECT MAX(h.`id`) AS `id`
, h.`staffId`
, h.`dateacquired`
FROM
JOIN ( SELECT l.`staffid`
, MAX(l.`dateacquired`) AS `max_dateacquired`
FROM `histories` l
WHERE l.`skillId` = '2'
GROUP BY l.`staffid`
) m
JOIN `histories` h
ON h.`dateacquired` = m.`max_dateacquired`
ON h.`staffid` = m.`staffid`
AND h.`skillId` = '2'
GROUP
BY h.`staffid`
, h.`dateacquired`
MySQL 8.0 introduced Window Functions, which gives us another way to get the specified result:
WITH w AS
( SELECT h.id
, h.staffid
, h.dateacquired
, ROW_NUMBER() OVER(PARTITION BY h.staffid ORDER BY h.dateacquired DESC, h.id DESC) AS _rn
FROM `histories` h
WHERE h.skillid = '2'
)
SELECT w.id
, w.staffid
, w.dateacquired
FROM w
WHERE _rn = 1
ORDER
BY w.staffid
We could also use an anti-join pattern, to retrieve rows where there isn't a later dateacquired... assuming id is unique in histories (or at least the (staffid,dateacquired,id) tuple is unique)
SELECT h.id
, h.staffid
, h.dateacquired
FROM `histories` h
-- anti-join
LEFT
JOIN `histories` l
ON l.skillid = '2'
AND l.staffid = h.staffid
AND l.dateacquired >= h.dateacquired
AND ( l.datecquired > h.dateacquired OR l.id > h.id )
WHERE l.staffid IS NULL
AND h.skillid = '2'
ORDER
BY h.staffid
We could accomplish the same thing, re-writing the anti-join as a NOT EXISTS
SELECT h.id
, h.staffid
, h.dateacquired
FROM `histories` h
WHERE h.skillid = '2'
AND NOT EXISTS
( SELECT 1
FROM `histories` l
WHERE l.skillid = '2'
AND l.staffid = h.staffid
AND l.dateacquired >= h.dateacquired
AND ( l.datecquired > h.dateacquired OR l.id > h.id )
)
(Note that some of these queries could be simplified a tiny bit if we have a guarantee that (staffid,skillid,dateacquired) tuple is unique. All of the queries above do not assume such a guarantee.)