Ответ 1

SELECT g, a, b, v
  FROM (
            SELECT *, 
                   @rn := IF(g = @g, @rn + 1, 1) rn, 
                   @g := g
              FROM (select @g := null, @rn := 0) x, 
                   tab
          ORDER BY g, a desc, b desc, v
       ) X
 WHERE rn = 1;

Одиночный проход. Все остальные решения выглядят O (n ^ 2) для меня.

Ответ 2

Этот способ не использует подзапрос.

SELECT t1.g, t1.v
FROM tab t1
LEFT JOIN tab t2 ON t1.g = t2.g AND (t1.a < t2.a OR (t1.a = t2.a AND t1.b < t2.b))
WHERE t2.g IS NULL

Объяснение:

LEFT JOIN работает на том основании, что когда t1.a находится на своем максимальном значении, нет s2.a с большим значением, а значения строк s2 будут NULL.

Ответ 3

Это можно решить, используя коррелированный запрос:

SELECT g, v
FROM tab t
WHERE NOT EXISTS (
    SELECT 1
    FROM tab
    WHERE g = t.g
        AND a > t.a
        OR (a = t.a AND b > t.b)
    )

Ответ 4

Во многих РСУБД есть конструкции, которые особенно подходят для этой проблемы. MySQL не является одним из них.

Это приводит к трем основным подходам.

• Проверьте каждую запись, чтобы убедиться, что она вам нужна, используя EXISTS и коррелированный подзапрос в предложении EXISTS. (@acatt ответ, но я понимаю, что MySQL не всегда оптимизирует это очень хорошо. Убедитесь, что у вас есть составной индекс на (g,a,b), прежде чем предположить, что MySQL не будет делать это очень хорошо.)

• Сделайте половину декартова продукта, чтобы заполнить ту же проверку. Любая запись, которая не соединяется, является целевой записью. Если каждая группа ( "g" ) велика, это может быстро ухудшить производительность (если для каждого уникального значения g будет 10 записей, это даст ~ 50 записей и отбросит 49. Для группового размера 100 оно дает ~ 5000 записей и отбросить 4999), но отлично подходит для небольших групп. (@xdazz ответ.)

• Или используйте несколько подзапросов для определения MAX (a), а затем MAX (b)...

Несколько последовательных подзапросов...

SELECT
  yourTable.*
FROM
  (SELECT g,    MAX(a) AS a FROM yourTable GROUP BY g   ) AS searchA
INNER JOIN
  (SELECT g, a, MAX(b) AS b FROM yourTable GROUP BY g, a) AS searchB
    ON  searchA.g = searchB.g
    AND searchA.a = searchB.a
INNER JOIN
  yourTable
    ON  yourTable.g = searchB.g
    AND yourTable.a = searchB.a
    AND yourTable.b = searchB.b

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

Предполагая составной индекс во всех трех полях поиска (g, a, b), я предполагаю, что он лучше всего подходит для больших размеров группы g. Но это должно быть проверено.

Для небольших размеров группы g я бы пошел с ответом @xdazz.

ИЗМЕНИТЬ

Существует также подход грубой силы.

• Создайте идентичную таблицу, но с столбцом AUTO_INCREMENT в качестве идентификатора.
• Вставьте таблицу в этот клон, упорядоченный по g, a, b.
• Затем идентификатор можно найти с помощью SELECT g, MAX(id).
• Этот результат можно затем использовать для поиска нужных значений v.

Это вряд ли будет лучшим подходом. Если это так, это действительно затрудняет способность оптимизатора MySQL справляться с этой проблемой.

Тем не менее, у каждого двигателя есть слабые места. Итак, лично я стараюсь все, пока не думаю, что понимаю, как работает РСУБД и может сделать мой выбор:)

ИЗМЕНИТЬ

Пример с помощью ROW_NUMBER(). (Oracle, SQL Server, PostGreSQL и т.д.)

SELECT
  *
FROM
(
  SELECT
    ROW_NUMBER() OVER (PARTITION BY g ORDER BY a DESC, b DESC) AS sequence_id,
    *
  FROM
    yourTable
)
  AS data
WHERE
  sequence_id = 1