SQL의 다른 열에 의해 MAX (열 값), DISTINCT를 사용하여 행을 어떻게 선택할 수 있습니까?

내 테이블은 :

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

home최대 값을 보유한 각 고유 항목을 선택해야합니다 datetime.

결과는 다음과 같습니다.

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

나는 시도했다 :

-- 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

작동하지 않습니다. 데이터베이스에 187 개가 있지만 결과 집합에 130 개의 행이 있습니다. 결과에의 일부 중복이 포함됩니다 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 

아니. 모든 기록을 제공합니다.

-- 3 ..something exotic: 

다양한 결과로.

당신은 너무 가깝습니다! 집과 최대 날짜 시간 topten을 모두 선택한 다음 BOTH 필드 의 테이블에 다시 가입하기 만하면됩니다.

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

MySQL내부 쿼리가없고없는 가장 빠른 솔루션 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

설명 :

home열을 사용하여 테이블 자체를 조인하십시오 . 를 사용 LEFT JOIN하면 테이블의 모든 행 m이 결과 집합에 나타납니다. 테이블에서 일치하지 않는 항목은 의 열에 대해을 b갖습니다 .NULLb

의 다른 조건은의 JOIN행 보다 열의 b값이 큰 행만 일치하도록 요청합니다 .datetimem

질문에 게시 된 데이터를 사용하면 다음과 LEFT JOIN같은 쌍이 생성됩니다.

+------------------------------------------+--------------------------------+
|              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       | ... | *
+------------------------------------------+--------------------------------+

마지막 WHERE으로이 절 NULL은 열에 s 가있는 쌍만 유지합니다 b( *위의 표에 표시되어 있음 ). 이는 JOIN절의 두 번째 조건으로 인해에서 선택된 행 m이 column에서 가장 큰 값을 갖음을 의미 datetime합니다.

다른 SQL 팁에 대해서는 SQL 안티 패턴 : 데이터베이스 프로그래밍의 함정 피하기 책을 읽으십시오 .

다음은 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

편집
불행히도 MySQL에는 RANK () OVER 함수가 없습니다.
그러나 에뮬레이션 할 수 있습니다 (MySQL로 분석 (AKA 순위) 함수 에뮬레이션 참조 ) .
따라서 이것은 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

이것은 당신이 각각 두 개 이상의 행이있을 경우에도 작동합니다 home동일한와 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

나는 이것이 당신에게 원하는 결과를 줄 것이라고 생각합니다 :

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

그러나 다른 열도 필요하면 원래 테이블과 조인하십시오 ( Michael La Voie답변 확인 ).

친애하는.

사람들 이이 스레드를 계속 실행하는 것처럼 보이기 때문에 (댓글 날짜 범위는 1.5 년입니다) 그리 간단하지 않습니다.

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

집계 함수가 필요하지 않습니다 ...

건배.

이것을 시도해 볼 수 있으며 큰 테이블의 경우 쿼리 성능이 향상됩니다. 각 가정에 대해 두 개 이상의 레코드가없고 날짜가 다른 경우 작동합니다. 더 나은 일반적인 MySQL 쿼리는 위의 Michael La Voie의 쿼리입니다.

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

또는 Postgres 또는 분석 기능을 제공하는 DB의 경우

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

이것은 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

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)

다음은 그룹에 MAX (datetime)가 중복되는 항목을 하나만 인쇄하는 MySQL 버전입니다.

http://www.sqlfiddle.com/#!2/0a4ae/1에서 테스트 할 수 있습니다 .

샘플 데이터

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 |
+------+------+---------------------+--------+----------+

사용자 변수가있는 MySQL 버전

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)

수락 된 답변

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)

기본적으로 그룹당 각 행의 순위를 계산 한 다음 순위 = 1과 같이 가장 최근의 행을 필터링하는 하위 쿼리를 사용하여 그룹당 가장 최근의 행을 나타내는 다른 방법

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

데모

다음은 이해를 돕기 위해 각 행의 순위 no에 대한 시각적 데모 입니다.

몇 가지 의견을 읽음으로써 'home'과 'datetime'필드 값이 같은 두 개의 행이 있다면 어떨까요?

위의 쿼리는 실패하고 위의 상황에 대해 둘 이상의 행을 반환합니다. 이 상황을 해결하기 위해서는 어떤 상황에서 어느 행을 취해야하는지 결정하기 위해 다른 기준 / 매개 변수 / 열이 필요합니다. 샘플 데이터 세트를 보면 id자동 증가로 설정해야하는 기본 키 열이 있다고 가정 합니다. 따라서이 열을 사용하여 다음 CASE과 같은 명령문을 사용하여 동일한 쿼리를 조정하여 가장 최근 행을 선택할 수 있습니다

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

데모

위의 쿼리는 동일한 datetime값 중에서 가장 높은 ID를 가진 행을 선택 합니다.

각 행의 순위 no에 대한 시각적 데모

사용하지 않는 이유 : SELECT home, MAX (datetime) AS MaxDateTime, player, resource FROM topten GROUP BY home 내가 놓친 부분이 있습니까?

이 시도

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

K에 감사합니다

이것은 당신이 필요로하는 쿼리입니다 :

 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 허용되는 답변은 대부분의 경우에 효과가 있지만 다음과 같이 실패합니다.

HomeID와 Datetime이 동일한 2 개의 행이있는 경우 쿼리는 아래와 같이 쿼리에 고유성을 추가하기 위해 필요에 따라 고유 한 HomeID가 아닌 두 행을 모두 반환합니다.

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

아래 쿼리에서 원하는 결과를 얻습니다.

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