Используя LIMIT внутри GROUP BY, чтобы получить N результатов для каждой группы?

Следующий запрос:

SELECT
year, id, rate
FROM h
WHERE year BETWEEN 2000 AND 2009
AND id IN (SELECT rid FROM table2)
GROUP BY id, year
ORDER BY id, rate DESC

дает:

year    id  rate
2006    p01 8
2003    p01 7.4
2008    p01 6.8
2001    p01 5.9
2007    p01 5.3
2009    p01 4.4
2002    p01 3.9
2004    p01 3.5
2005    p01 2.1
2000    p01 0.8
2001    p02 12.5
2004    p02 12.4
2002    p02 12.2
2003    p02 10.3
2000    p02 8.7
2006    p02 4.6
2007    p02 3.3

Мне бы хотелось только получить 5 лучших результатов для каждого id:

2006    p01 8
2003    p01 7.4
2008    p01 6.8
2001    p01 5.9
2007    p01 5.3
2001    p02 12.5
2004    p02 12.4
2002    p02 12.2
2003    p02 10.3
2000    p02 8.7

Есть ли способ сделать это, используя какой-то модификатор LIMIT, который работает в GROUP BY?

293
задан Wells 25 янв. '10 в 4:25
источник поделиться

14 ответов

Вы можете использовать агрегированную функцию GROUP_CONCAT, чтобы получить все годы в один столбец, сгруппированный по id и упорядоченный по rate:

SELECT   id, GROUP_CONCAT(year ORDER BY rate DESC) grouped_year
FROM     yourtable
GROUP BY id

Результат:

-----------------------------------------------------------
|  ID | GROUPED_YEAR                                      |
-----------------------------------------------------------
| p01 | 2006,2003,2008,2001,2007,2009,2002,2004,2005,2000 |
| p02 | 2001,2004,2002,2003,2000,2006,2007                |
-----------------------------------------------------------

И затем вы можете использовать FIND_IN_SET, который возвращает позицию первого аргумента во втором, например.

SELECT FIND_IN_SET('2006', '2006,2003,2008,2001,2007,2009,2002,2004,2005,2000');
1

SELECT FIND_IN_SET('2009', '2006,2003,2008,2001,2007,2009,2002,2004,2005,2000');
6

Используя комбинацию GROUP_CONCAT и FIND_IN_SET и фильтруя по позиции, возвращаемой find_in_set, вы можете использовать этот запрос, который возвращает только первые 5 лет для каждого id:

SELECT
  yourtable.*
FROM
  yourtable INNER JOIN (
    SELECT
      id,
      GROUP_CONCAT(year ORDER BY rate DESC) grouped_year
    FROM
      yourtable
    GROUP BY id) group_max
  ON yourtable.id = group_max.id
     AND FIND_IN_SET(year, grouped_year) BETWEEN 1 AND 5
ORDER BY
  yourtable.id, yourtable.year DESC;

Смотрите здесь скрипку здесь.

Обратите внимание, что если более одной строки может иметь одинаковый коэффициент, вам следует рассмотреть возможность использования GROUP_CONCAT (DISTINCT rate ORDER BY rate) в столбце скорости вместо столбца года.

Максимальная длина строки, возвращаемой GROUP_CONCAT, ограничена, поэтому это хорошо работает, если вам нужно выбрать несколько записей для каждой группы.

81
ответ дан fthiella 23 марта '13 в 12:47
источник поделиться

исходный запрос использовал пользовательские переменные и ORDER BY в производных таблицах; поведение обоих причуд не гарантируется. Пересмотренный ответ выглядит следующим образом.

Для достижения желаемого результата вы можете использовать бедный человек в ранге над разделом. Просто внешнее соединение таблицы с самим собой и для каждой строки подсчитывает количество строк меньше, чем оно:

SELECT testdata.id, testdata.rate, testdata.year, COUNT(lesser.rate) AS rank
FROM testdata
LEFT JOIN testdata AS lesser ON testdata.id = lesser.id AND testdata.rate < lesser.rate
GROUP BY testdata.id, testdata.rate, testdata.year
HAVING COUNT(lesser.rate) < 5
ORDER BY testdata.id, testdata.rate DESC

Обратите внимание, что:

  • COUNT основан на нулевом уровне
  • Для сортировки по убыванию меньшая строка - с более высокой скоростью
  • Все строки, привязанные для последнего места, возвращаются

Результат:

+------+-------+------+------+
| id   | rate  | year | rank |
+------+-------+------+------+
| p01  |  8.00 | 2006 |    0 |
| p01  |  7.40 | 2003 |    1 |
| p01  |  6.80 | 2008 |    2 |
| p01  |  5.90 | 2001 |    3 |
| p01  |  5.30 | 2007 |    4 |
| p02  | 12.50 | 2001 |    0 |
| p02  | 12.40 | 2004 |    1 |
| p02  | 12.20 | 2002 |    2 |
| p02  | 10.30 | 2003 |    3 |
| p02  |  8.70 | 2000 |    4 |
+------+-------+------+------+
66
ответ дан Salman A 16 мая '15 в 0:49
источник поделиться

Для меня что-то вроде

SUBSTRING_INDEX(group_concat(col_name order by desired_col_order_name), ',', N) 

работает отлично. Нет сложного запроса.


например: получить верхнюю 1 для каждой группы

SELECT 
    *
FROM
    yourtable
WHERE
    id IN (SELECT 
            SUBSTRING_INDEX(GROUP_CONCAT(id
                            ORDER BY rate DESC),
                        ',',
                        1) id
        FROM
            yourtable
        GROUP BY year)
ORDER BY rate DESC;
13
ответ дан Vishal Kumar 04 окт. '13 в 18:35
источник поделиться

Нет, вы не можете LIMIT подзапросы произвольно (вы можете сделать это в ограниченной степени в новых MySQL, но не для 5 результатов для каждой группы).

Это запрос типа groupwise-maximum, который не является тривиальным для SQL. Существуют различные способы для решения того, что может быть более эффективным для некоторых случаев, но для top-n вообще вы захотите посмотреть ответьте на ответ на аналогичный предыдущий вопрос.

Как и в большинстве решений этой проблемы, он может возвращать более пяти строк, если имеется несколько строк с тем же значением rate, поэтому вам может потребоваться некоторое количество пост-обработки, чтобы проверить это.

8
ответ дан bobince 25 янв. '10 в 4:37
источник поделиться

Попробуйте следующее:

SELECT h.year, h.id, h.rate 
FROM (SELECT h.year, h.id, h.rate, IF(@lastid = (@lastid:=h.id), @index:=@index+1, @index:=0) indx 
      FROM (SELECT h.year, h.id, h.rate 
            FROM h
            WHERE h.year BETWEEN 2000 AND 2009 AND id IN (SELECT rid FROM table2)
            GROUP BY id, h.year
            ORDER BY id, rate DESC
            ) h, (SELECT @lastid:='', @index:=0) AS a
    ) h 
WHERE h.indx <= 5;
8
ответ дан Saharsh Shah 05 янв. '13 в 12:37
источник поделиться

Для этого требуется ряд подзапросов для ранжирования значений, их ограничения, затем выполнения суммы при группировке

@Rnk:=0;
@N:=2;
select
  c.id,
  sum(c.val)
from (
select
  b.id,
  b.bal
from (
select   
  if(@last_id=id,@Rnk+1,1) as Rnk,
  a.id,
  a.val,
  @last_id=id,
from (   
select 
  id,
  val 
from list
order by id,val desc) as a) as b
where b.rnk < @N) as c
group by c.id;
7
ответ дан Brian L Cartwright 02 нояб. '12 в 3:11
источник поделиться

Создайте виртуальные столбцы (например, RowID в Oracle)

Таблица:

`
CREATE TABLE `stack` 
(`year` int(11) DEFAULT NULL,
`id` varchar(10) DEFAULT NULL,
`rate` float DEFAULT NULL) 
ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
`

Данные:

insert into stack values(2006,'p01',8);
insert into stack values(2001,'p01',5.9);
insert into stack values(2007,'p01',5.3);
insert into stack values(2009,'p01',4.4);
insert into stack values(2001,'p02',12.5);
insert into stack values(2004,'p02',12.4);
insert into stack values(2005,'p01',2.1);
insert into stack values(2000,'p01',0.8);
insert into stack values(2002,'p02',12.2);
insert into stack values(2002,'p01',3.9);
insert into stack values(2004,'p01',3.5);
insert into stack values(2003,'p02',10.3);
insert into stack values(2000,'p02',8.7);
insert into stack values(2006,'p02',4.6);
insert into stack values(2007,'p02',3.3);
insert into stack values(2003,'p01',7.4);
insert into stack values(2008,'p01',6.8);

SQL:

select t3.year,t3.id,t3.rate 
from (select t1.*, (select count(*) from stack t2 where t1.rate<=t2.rate and t1.id=t2.id) as rownum from stack t1) t3 
where rownum <=3 order by id,rate DESC;

если удалить предложение where в t3, оно выглядит следующим образом:

введите описание изображения здесь

GET "TOP N Record" → добавить "rownum <= 3" в разделе where (where-clause t3);

ВЫБЕРИТЕ "год" → добавить "МЕЖДУ 2000 И 2009" в разделе where (where-clause t3);

4
ответ дан Wang Wen'an 09 мая '16 в 13:16
источник поделиться

Взял немного работы, но я решил, что мое решение будет чем-то разделяться, поскольку оно кажется элегантным, а также довольно быстрым.

SELECT h.year, h.id, h.rate 
  FROM (
    SELECT id, 
      SUBSTRING_INDEX(GROUP_CONCAT(CONCAT(id, '-', year) ORDER BY rate DESC), ',' , 5) AS l
      FROM h
      WHERE year BETWEEN 2000 AND 2009
      GROUP BY id
      ORDER BY id
  ) AS h_temp
    LEFT JOIN h ON h.id = h_temp.id 
      AND SUBSTRING_INDEX(h_temp.l, CONCAT(h.id, '-', h.year), 1) != h_temp.l

Обратите внимание, что этот пример указан для целей вопроса и может быть легко модифицирован для других аналогичных целей.

3
ответ дан John 25 окт. '16 в 16:20
источник поделиться

Следующая запись: sql: selcting top N записей для каждой группы описывает сложный способ достижения этого без подзапросов.

Это улучшает другие решения, предлагаемые здесь:

  • Выполнение всего в одном запросе
  • Возможность правильно использовать индексы
  • Предотвращение подзапросов, которые, как известно, создают плохие планы выполнения в MySQL

Это, однако, не очень. Хорошим решением было бы возможно, если в MySQL были включены функции Window (aka Analytic Functions), но это не так. В трюке, используемой в указанном сообщении, используется GROUP_CONCAT, который иногда описывается как "Функции окна для MySQL".

2
ответ дан Shlomi Noach 06 июля '12 в 20:10
источник поделиться
SELECT year, id, rate
FROM (SELECT
  year, id, rate, row_number() over (partition by id order by rate DESC)
  FROM h
  WHERE year BETWEEN 2000 AND 2009
  AND id IN (SELECT rid FROM table2)
  GROUP BY id, year
  ORDER BY id, rate DESC) as subquery
WHERE row_number <= 5

Подзапрос почти идентичен вашему запросу. Только изменение добавляет

row_number() over (partition by id order by rate DESC)
1
ответ дан Ricky Moreno 29 нояб. '12 в 3:04
источник поделиться

Попробуйте следующее:

SET @num := 0, @type := '';
SELECT `year`, `id`, `rate`,
    @num := if(@type = `id`, @num + 1, 1) AS `row_number`,
    @type := `id` AS `dummy`
FROM (
    SELECT *
    FROM `h`
    WHERE (
        `year` BETWEEN '2000' AND '2009'
        AND `id` IN (SELECT `rid` FROM `table2`) AS `temp_rid`
    )
    ORDER BY `id`
) AS `temph`
GROUP BY `year`, `id`, `rate`
HAVING `row_number`<='5'
ORDER BY `id`, `rate DESC;
1
ответ дан MLF 24 дек. '14 в 11:07
источник поделиться

для таких, как я, у которых были тайм-ауты запросов. Я сделал следующее, чтобы использовать ограничения и все остальное определенной группой.

DELIMITER $$
CREATE PROCEDURE count_limit200()
BEGIN
    DECLARE a INT Default 0;
    DECLARE stop_loop INT Default 0;
    DECLARE domain_val VARCHAR(250);
    DECLARE domain_list CURSOR FOR SELECT DISTINCT domain FROM db.one;

    OPEN domain_list;

    SELECT COUNT(DISTINCT(domain)) INTO stop_loop 
    FROM db.one;
    -- BEGIN LOOP
    loop_thru_domains: LOOP
        FETCH domain_list INTO domain_val;
        SET a=a+1;

        INSERT INTO db.two(book,artist,title,title_count,last_updated) 
        SELECT * FROM 
        (
            SELECT book,artist,title,COUNT(ObjectKey) AS titleCount, NOW() 
            FROM db.one 
            WHERE book = domain_val
            GROUP BY artist,title
            ORDER BY book,titleCount DESC
            LIMIT 200
        ) a ON DUPLICATE KEY UPDATE title_count = titleCount, last_updated = NOW();

        IF a = stop_loop THEN
            LEAVE loop_thru_domain;
        END IF;
    END LOOP loop_thru_domain;
END $$

он перебирает список доменов, а затем вставляет только 200-значный предел

1
ответ дан Dev-Ria 17 дек. '12 в 20:14
источник поделиться

Пожалуйста, попробуйте выполнить хранимую процедуру. Я уже проверял. Я получаю правильный результат, но без использования groupby.

CREATE DEFINER=`ks_root`@`%` PROCEDURE `first_five_record_per_id`()
BEGIN
DECLARE query_string text;
DECLARE datasource1 varchar(24);
DECLARE done INT DEFAULT 0;
DECLARE tenants varchar(50);
DECLARE cur1 CURSOR FOR SELECT rid FROM demo1;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1;

    SET @query_string='';

      OPEN cur1;
      read_loop: LOOP

      FETCH cur1 INTO tenants ;

      IF done THEN
        LEAVE read_loop;
      END IF;

      SET @datasource1 = tenants;
      SET @query_string = concat(@query_string,'(select * from demo  where `id` = ''',@datasource1,''' order by rate desc LIMIT 5) UNION ALL ');

       END LOOP; 
      close cur1;

    SET @query_string  = TRIM(TRAILING 'UNION ALL' FROM TRIM(@query_string));  
  select @query_string;
PREPARE stmt FROM @query_string;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;

END
0
ответ дан Himanshu Patel 15 июля '16 в 15:39
источник поделиться

Следующие группы запросов записываются на основе Grouping_COL и поэтапно назначают row_number каждой записи в каждой группе. Затем вы можете выполнить выбор, чтобы вернуть все записи, у которых количество строк меньше, чем счет.

SELECT
    Grouping_COL ,
    rownum_cnt
FROM
    (
        SELECT 
            Grouping_COL,
            row_number() OVER (PARTITION BY Grouping_COL) AS rownum_cnt
        FROM MyTable
    )
WHERE rownum_cnt  <= 100
-1
ответ дан Greenish 04 дек. '17 в 7:48
поделиться

Другие вопросы по меткам