Как я могу SELECT строк с MAX (значение столбца), DISTINCT другим столбцом в SQL?

Ответ 1

Ты так близко! Все, что вам нужно сделать, это выбрать BOTH home и it max date time, а затем присоединиться к таблице 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

Ответ 2

Ниже приведена версия 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.
Но его можно эмулировать, см. Функции эмуляции аналитического (AKA) с MySQL.
Итак, это версия 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

Ответ 3

Самое быстрое решение 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, будут иметь NULL для столбцов b.

Другое условие в JOIN требует совместить только строки из b, которые имеют большее значение в столбце datetime, чем строка из m.

Используя данные, опубликованные в вопросе, 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 в столбцах b (они помечены знаком * в таблице выше); это означает, что из-за второго условия из предложения JOIN строка, выбранная из m, имеет наибольшее значение в столбце datetime.

Прочтите SQL Antipatterns: Avoid the Pitfalls of Database Programming для других советов SQL.

Ответ 4

Это будет работать, даже если у вас есть две или несколько строк для каждого 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

Ответ 5

Я думаю, что это даст вам желаемый результат:

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

НО, если вам нужны и другие столбцы, просто сделайте соединение с исходной таблицей (проверьте Michael La Voie ответ)

С уважением.

Ответ 6

Так как люди, похоже, продолжают работать в этом потоке (диапазон комментариев составляет от 1,5 года), это не намного проще:

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

Никаких функций агрегации не требуется...

Приветствия.

Ответ 7

Вы также можете попробовать это, а для больших таблиц производительность запросов будет лучше. Он работает, когда для каждого дома не более двух записей, а их даты разные. Лучший общий запрос MySQL - один из Майкла Ла Фой выше.

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 или тех dbs, которые предоставляют аналитические функции, попробуйте

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

Ответ 8

Это работает на 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

Ответ 9

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

Ответ 10

Попробуйте это для 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

Ответ 11

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)

Ответ 12

Попробуйте это

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

Отношения К

Ответ 13

Вот версия MySQL, которая печатает только одну запись, в которой есть дубликаты MAX (datetime) в группе.

Вы можете проверить здесь 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)

Ответ 14

Почему бы не использовать: SELECT home, MAX (datetime) AS MaxDateTime, проигрыватель, ресурс FROM topten GROUP BY home Я что-то пропустил?

Ответ 15

это необходимый вам запрос:

 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;

Ответ 16

@Michae. Принятый ответ будет отлично работать в большинстве случаев, но он не подходит для одного, как показано ниже.

Если бы было 2 строки с идентификатором HomeID и Datetime, то запрос возвратит обе строки, а не отдельный идентификатор HomeID по мере необходимости, для этого добавьте Distinct в запрос, как показано ниже.

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

Ответ 17

Другой путь к последней строке для каждой группы с использованием подзапроса, который в основном вычисляет ранг для каждой строки для каждой группы, а затем отфильтровывает ваши последние строки так же, как 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

DEMO

Вот визуальная демонстрация для ранга no для каждой строки для лучшего понимания

Прочитав несколько комментариев , если есть две строки, которые имеют одинаковые значения поля "home" и "datetime"?

Выше запроса не удастся и вернет более 1 строки для указанной выше ситуации. Чтобы скрыть эту ситуацию, потребуется другой критерий/параметр/столбец, чтобы решить, какую строку следует принять, которая попадает в ситуацию выше. Просматривая образец данных, я предполагаю, что есть столбец первичного ключа 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

DEMO

Выше запроса будет выбирать строку с наивысшим идентификатором среди тех же datetime значений

визуальная демонстрация для ранга no для каждой строки