Làm cách nào tôi có thể CHỌN các hàng với MAX (Giá trị cột), DISTINCT bằng một cột khác trong SQL?

Bảng của tôi là:

id  home  datetime     player   resource
---|-----|------------|--------|---------
1  | 10  | 04/03/2009 | john   | 399 
2  | 11  | 04/03/2009 | juliet | 244
5  | 12  | 04/03/2009 | borat  | 555
3  | 10  | 03/03/2009 | john   | 300
4  | 11  | 03/03/2009 | juliet | 200
6  | 12  | 03/03/2009 | borat  | 500
7  | 13  | 24/12/2008 | borat  | 600
8  | 13  | 01/01/2009 | borat  | 700

Tôi cần phải chọn mỗi khác biệt homegiữ giá trị tối đa của datetime.

Kết quả sẽ là:

id  home  datetime     player   resource 
---|-----|------------|--------|---------
1  | 10  | 04/03/2009 | john   | 399
2  | 11  | 04/03/2009 | juliet | 244
5  | 12  | 04/03/2009 | borat  | 555
8  | 13  | 01/01/2009 | borat  | 700

Tôi đã thử:

-- 1 ..by the MySQL manual: 

SELECT DISTINCT
  home,
  id,
  datetime AS dt,
  player,
  resource
FROM topten t1
WHERE datetime = (SELECT
  MAX(t2.datetime)
FROM topten t2
GROUP BY home)
GROUP BY datetime
ORDER BY datetime DESC

Không hoạt động. Tập kết quả có 130 hàng mặc dù cơ sở dữ liệu chứa 187. Kết quả bao gồm một số bản sao của home.

-- 2 ..join

SELECT
  s1.id,
  s1.home,
  s1.datetime,
  s1.player,
  s1.resource
FROM topten s1
JOIN (SELECT
  id,
  MAX(datetime) AS dt
FROM topten
GROUP BY id) AS s2
  ON s1.id = s2.id
ORDER BY datetime 

Không. Cung cấp tất cả các hồ sơ.

-- 3 ..something exotic: 

Với kết quả khác nhau.

Bạn thật gần gũi! Tất cả những gì bạn cần làm là chọn CẢ HAI nhà và thời gian ngày tối đa của nó, sau đó tham gia trở lại toptenbảng trên các trường CẢ:

SELECT tt.*
FROM topten tt
INNER JOIN
    (SELECT home, MAX(datetime) AS MaxDateTime
    FROM topten
    GROUP BY home) groupedtt 
ON tt.home = groupedtt.home 
AND tt.datetime = groupedtt.MaxDateTime

MySQLGiải pháp nhanh nhất , không có truy vấn bên trong và không có GROUP BY:

SELECT m.*                    -- get the row that contains the max value
FROM topten m                 -- "m" from "max"
    LEFT JOIN topten b        -- "b" from "bigger"
        ON m.home = b.home    -- match "max" row with "bigger" row by `home`
        AND m.datetime < b.datetime           -- want "bigger" than "max"
WHERE b.datetime IS NULL      -- keep only if there is no bigger than max

Giải thích :

Tham gia bảng với chính nó bằng cách sử dụng homecột. Việc sử dụng LEFT JOINđảm bảo tất cả các hàng từ bảng mxuất hiện trong tập kết quả. Những người không có trận đấu trong bảng bsẽ có NULLs cho các cột của b.

Điều kiện khác trên các JOINyêu cầu chỉ khớp với các hàng từ bđó có giá trị lớn hơn trên datetimecột so với hàng từ m.

Sử dụng dữ liệu được đăng trong câu hỏi, LEFT JOINsẽ tạo ra cặp này:

+------------------------------------------+--------------------------------+
|              the row from `m`            |    the matching row from `b`   |
|------------------------------------------|--------------------------------|
| id  home  datetime     player   resource | id    home   datetime      ... |
|----|-----|------------|--------|---------|------|------|------------|-----|
| 1  | 10  | 04/03/2009 | john   | 399     | NULL | NULL | NULL       | ... | *
| 2  | 11  | 04/03/2009 | juliet | 244     | NULL | NULL | NULL       | ... | *
| 5  | 12  | 04/03/2009 | borat  | 555     | NULL | NULL | NULL       | ... | *
| 3  | 10  | 03/03/2009 | john   | 300     | 1    | 10   | 04/03/2009 | ... |
| 4  | 11  | 03/03/2009 | juliet | 200     | 2    | 11   | 04/03/2009 | ... |
| 6  | 12  | 03/03/2009 | borat  | 500     | 5    | 12   | 04/03/2009 | ... |
| 7  | 13  | 24/12/2008 | borat  | 600     | 8    | 13   | 01/01/2009 | ... |
| 8  | 13  | 01/01/2009 | borat  | 700     | NULL | NULL | NULL       | ... | *
+------------------------------------------+--------------------------------+

Cuối cùng, WHEREmệnh đề chỉ giữ các cặp có NULLs trong các cột của b(chúng được đánh dấu *trong bảng trên); điều này có nghĩa, do điều kiện thứ hai từ JOINmệnh đề, hàng được chọn từ mcó giá trị lớn nhất trong cột datetime.

Đọc các Antipotype của SQL: Tránh các cạm bẫy của cuốn sách Lập trình cơ sở dữ liệu cho các mẹo SQL khác.

Đây là phiên bản T-SQL :

-- Test data
DECLARE @TestTable TABLE (id INT, home INT, date DATETIME, 
  player VARCHAR(20), resource INT)
INSERT INTO @TestTable
SELECT 1, 10, '2009-03-04', 'john', 399 UNION
SELECT 2, 11, '2009-03-04', 'juliet', 244 UNION
SELECT 5, 12, '2009-03-04', 'borat', 555 UNION
SELECT 3, 10, '2009-03-03', 'john', 300 UNION
SELECT 4, 11, '2009-03-03', 'juliet', 200 UNION
SELECT 6, 12, '2009-03-03', 'borat', 500 UNION
SELECT 7, 13, '2008-12-24', 'borat', 600 UNION
SELECT 8, 13, '2009-01-01', 'borat', 700

-- Answer
SELECT id, home, date, player, resource 
FROM (SELECT id, home, date, player, resource, 
    RANK() OVER (PARTITION BY home ORDER BY date DESC) N
    FROM @TestTable
)M WHERE N = 1

-- and if you really want only home with max date
SELECT T.id, T.home, T.date, T.player, T.resource 
    FROM @TestTable T
INNER JOIN 
(   SELECT TI.id, TI.home, TI.date, 
        RANK() OVER (PARTITION BY TI.home ORDER BY TI.date) N
    FROM @TestTable TI
    WHERE TI.date IN (SELECT MAX(TM.date) FROM @TestTable TM)
)TJ ON TJ.N = 1 AND T.id = TJ.id

EDIT
Thật không may, không có hàm RANK () OVER trong MySQL.
Nhưng nó có thể được mô phỏng, xem Hàm mô phỏng phân tích (Xếp hạng AKA) với MySQL .
Vì vậy, đây là phiên bản MySQL :

SELECT id, home, date, player, resource 
FROM TestTable AS t1 
WHERE 
    (SELECT COUNT(*) 
            FROM TestTable AS t2 
            WHERE t2.home = t1.home AND t2.date > t1.date
    ) = 0

Điều này sẽ hoạt động ngay cả khi bạn có hai hoặc nhiều hàng cho mỗi hàng homebằng nhau DATETIME:

SELECT id, home, datetime, player, resource
FROM   (
       SELECT (
              SELECT  id
              FROM    topten ti
              WHERE   ti.home = t1.home
              ORDER BY
                      ti.datetime DESC
              LIMIT 1
              ) lid
       FROM   (
              SELECT  DISTINCT home
              FROM    topten
              ) t1
       ) ro, topten t2
WHERE  t2.id = ro.lid

Tôi nghĩ rằng điều này sẽ cung cấp cho bạn kết quả mong muốn:

SELECT   home, MAX(datetime)
FROM     my_table
GROUP BY home

NHƯNG nếu bạn cũng cần các cột khác, chỉ cần thực hiện nối với bảng gốc (kiểm tra Michael La Voiecâu trả lời)

Trân trọng.

Vì mọi người dường như tiếp tục chạy vào chủ đề này (ngày bình luận trong khoảng 1,5 năm) không đơn giản hơn nhiều:

SELECT * FROM (SELECT * FROM topten ORDER BY datetime DESC) tmp GROUP BY home

Không có chức năng tổng hợp cần thiết ...

Chúc mừng.

Bạn cũng có thể thử cái này và cho hiệu suất truy vấn bảng lớn sẽ tốt hơn. Nó hoạt động khi không có nhiều hơn hai hồ sơ cho mỗi nhà và ngày của họ là khác nhau. Truy vấn MySQL chung tốt hơn là một từ Michael La Voie ở trên.

SELECT t1.id, t1.home, t1.date, t1.player, t1.resource
FROM   t_scores_1 t1 
INNER JOIN t_scores_1 t2
   ON t1.home = t2.home
WHERE t1.date > t2.date

Hoặc trong trường hợp Postgres hoặc những dbs cung cấp chức năng phân tích, hãy thử

SELECT t.* FROM 
(SELECT t1.id, t1.home, t1.date, t1.player, t1.resource
  , row_number() over (partition by t1.home order by t1.date desc) rw
 FROM   topten t1 
 INNER JOIN topten t2
   ON t1.home = t2.home
 WHERE t1.date > t2.date 
) t
WHERE t.rw = 1

Điều này hoạt động trên Oracle:

with table_max as(
  select id
       , home
       , datetime
       , player
       , resource
       , max(home) over (partition by home) maxhome
    from table  
)
select id
     , home
     , datetime
     , player
     , resource
  from table_max
 where home = maxhome

SELECT  tt.*
FROM    TestTable tt 
INNER JOIN 
        (
        SELECT  coord, MAX(datetime) AS MaxDateTime 
        FROM    rapsa 
        GROUP BY
                krd 
        ) groupedtt
ON      tt.coord = groupedtt.coord
        AND tt.datetime = groupedtt.MaxDateTime

Hãy thử điều này cho SQL Server:

WITH cte AS (
   SELECT home, MAX(year) AS year FROM Table1 GROUP BY home
)
SELECT * FROM Table1 a INNER JOIN cte ON a.home = cte.home AND a.year = cte.year

SELECT c1, c2, c3, c4, c5 FROM table1 WHERE c3 = (select max(c3) from table)

SELECT * FROM table1 WHERE c3 = (select max(c3) from table1)

Đây là phiên bản MySQL chỉ in một mục trong đó có các bản sao MAX (datetime) trong một nhóm.

Bạn có thể kiểm tra tại đây http://www.sqlfiddle.com/#!2/0a4ae/1

Dữ liệu mẫu

mysql> SELECT * from topten;
+------+------+---------------------+--------+----------+
| id   | home | datetime            | player | resource |
+------+------+---------------------+--------+----------+
|    1 |   10 | 2009-04-03 00:00:00 | john   |      399 |
|    2 |   11 | 2009-04-03 00:00:00 | juliet |      244 |
|    3 |   10 | 2009-03-03 00:00:00 | john   |      300 |
|    4 |   11 | 2009-03-03 00:00:00 | juliet |      200 |
|    5 |   12 | 2009-04-03 00:00:00 | borat  |      555 |
|    6 |   12 | 2009-03-03 00:00:00 | borat  |      500 |
|    7 |   13 | 2008-12-24 00:00:00 | borat  |      600 |
|    8 |   13 | 2009-01-01 00:00:00 | borat  |      700 |
|    9 |   10 | 2009-04-03 00:00:00 | borat  |      700 |
|   10 |   11 | 2009-04-03 00:00:00 | borat  |      700 |
|   12 |   12 | 2009-04-03 00:00:00 | borat  |      700 |
+------+------+---------------------+--------+----------+

Phiên bản MySQL với biến người dùng

SELECT *
FROM (
    SELECT ord.*,
        IF (@prev_home = ord.home, 0, 1) AS is_first_appear,
        @prev_home := ord.home
    FROM (
        SELECT t1.id, t1.home, t1.player, t1.resource
        FROM topten t1
        INNER JOIN (
            SELECT home, MAX(datetime) AS mx_dt
            FROM topten
            GROUP BY home
          ) x ON t1.home = x.home AND t1.datetime = x.mx_dt
        ORDER BY home
    ) ord, (SELECT @prev_home := 0, @seq := 0) init
) y
WHERE is_first_appear = 1;
+------+------+--------+----------+-----------------+------------------------+
| id   | home | player | resource | is_first_appear | @prev_home := ord.home |
+------+------+--------+----------+-----------------+------------------------+
|    9 |   10 | borat  |      700 |               1 |                     10 |
|   10 |   11 | borat  |      700 |               1 |                     11 |
|   12 |   12 | borat  |      700 |               1 |                     12 |
|    8 |   13 | borat  |      700 |               1 |                     13 |
+------+------+--------+----------+-----------------+------------------------+
4 rows in set (0.00 sec)

Ra ngoài câu trả lời được chấp nhận

SELECT tt.*
FROM topten tt
INNER JOIN
    (
    SELECT home, MAX(datetime) AS MaxDateTime
    FROM topten
    GROUP BY home
) groupedtt ON tt.home = groupedtt.home AND tt.datetime = groupedtt.MaxDateTime
+------+------+---------------------+--------+----------+
| id   | home | datetime            | player | resource |
+------+------+---------------------+--------+----------+
|    1 |   10 | 2009-04-03 00:00:00 | john   |      399 |
|    2 |   11 | 2009-04-03 00:00:00 | juliet |      244 |
|    5 |   12 | 2009-04-03 00:00:00 | borat  |      555 |
|    8 |   13 | 2009-01-01 00:00:00 | borat  |      700 |
|    9 |   10 | 2009-04-03 00:00:00 | borat  |      700 |
|   10 |   11 | 2009-04-03 00:00:00 | borat  |      700 |
|   12 |   12 | 2009-04-03 00:00:00 | borat  |      700 |
+------+------+---------------------+--------+----------+
7 rows in set (0.00 sec)

Một cách khác để gt hàng gần đây nhất cho mỗi nhóm bằng cách sử dụng truy vấn phụ, về cơ bản sẽ tính thứ hạng cho mỗi hàng cho mỗi nhóm và sau đó lọc ra các hàng gần đây nhất của bạn như với rank = 1

select a.*
from topten a
where (
  select count(*)
  from topten b
  where a.home = b.home
  and a.`datetime` < b.`datetime`
) +1 = 1

BẢN GIỚI THIỆU

Dưới đây là bản demo trực quan để xếp hạng không cho mỗi hàng để hiểu rõ hơn

Bằng cách đọc một số nhận xét về việc nếu có hai hàng có cùng giá trị trường 'home' và 'datetime' thì sao?

Truy vấn trên sẽ thất bại và sẽ trả về hơn 1 hàng cho tình huống trên. Để che đậy tình huống này, sẽ cần một tiêu chí / tham số / cột khác để quyết định hàng nào sẽ được thực hiện trong tình huống trên. Bằng cách xem tập dữ liệu mẫu, tôi giả sử có một cột khóa chính idsẽ được đặt thành tăng tự động. Vì vậy, chúng ta có thể sử dụng cột này để chọn hàng gần đây nhất bằng cách điều chỉnh cùng một truy vấn với sự trợ giúp của CASEcâu lệnh như

select a.*
from topten a
where (
  select count(*)
  from topten b
  where a.home = b.home
  and  case 
       when a.`datetime` = b.`datetime`
       then a.id < b.id
       else a.`datetime` < b.`datetime`
       end
) + 1 = 1

BẢN GIỚI THIỆU

Truy vấn trên sẽ chọn hàng có id cao nhất trong số các datetimegiá trị tương tự

bản demo trực quan cho thứ hạng không cho mỗi hàng

Tại sao không sử dụng: CHỌN nhà, MAX (datetime) NHƯ MaxDateTime, trình phát, tài nguyên TỪ topten NHÓM Ở nhà Tôi có bỏ lỡ điều gì không?

Thử cái này

select * from mytable a join
(select home, max(datetime) datetime
from mytable
group by home) b
 on a.home = b.home and a.datetime = b.datetime

Trân trọng

đây là truy vấn bạn cần:

 SELECT b.id, a.home,b.[datetime],b.player,a.resource FROM
 (SELECT home,MAX(resource) AS resource FROM tbl_1 GROUP BY home) AS a

 LEFT JOIN

 (SELECT id,home,[datetime],player,resource FROM tbl_1) AS b
 ON  a.resource = b.resource WHERE a.home =b.home;

@Michae Câu trả lời được chấp nhận sẽ hoạt động tốt trong hầu hết các trường hợp nhưng nó không thành công cho một câu như dưới đây.

Trong trường hợp nếu có 2 hàng có HomeID và Datetime giống nhau thì truy vấn sẽ trả về cả hai hàng, không phân biệt HomeID theo yêu cầu, cho điều đó thêm Phân biệt trong truy vấn như bên dưới.

SELECT DISTINCT tt.home  , tt.MaxDateTime
FROM topten tt
INNER JOIN
    (SELECT home, MAX(datetime) AS MaxDateTime
    FROM topten
    GROUP BY home) groupedtt 
ON tt.home = groupedtt.home 
AND tt.datetime = groupedtt.MaxDateTime

Hy vọng bên dưới truy vấn sẽ cho đầu ra mong muốn:

Select id, home,datetime,player,resource, row_number() over (Partition by home ORDER by datetime desc) as rownum from tablename where rownum=1