Sử dụng GIỚI HẠN trong NHÓM THEO để nhận N kết quả cho mỗi nhóm?

Truy vấn sau đây:

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

sản lượng:

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

Điều tôi muốn chỉ là 5 kết quả hàng đầu cho mỗi 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

Có cách nào để thực hiện việc này bằng cách sử dụng một số loại GIỚI HẠN như công cụ sửa đổi hoạt động trong NHÓM B BYNG KHÔNG?

Bạn có thể sử dụng hàm tổng hợp GROUP_CONCAT để có được tất cả các năm trong một cột duy nhất, được nhóm theo idvà được sắp xếp theo rate:

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

Kết quả:

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

Và sau đó, bạn có thể sử dụng FIND_IN_SET , trả về vị trí của đối số thứ nhất bên trong đối số thứ hai, ví dụ:

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

Sử dụng kết hợp GROUP_CONCATvà FIND_IN_SETvà lọc theo vị trí được trả về bởi find_in_set, sau đó bạn có thể sử dụng truy vấn này chỉ trả về 5 năm đầu tiên cho mỗi 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;

Xin vui lòng xem fiddle ở đây .

Xin lưu ý rằng nếu nhiều hơn một hàng có thể có cùng tỷ lệ, bạn nên cân nhắc sử dụng GROUP_CONCAT (tỷ lệ DISTINCT tỷ lệ ORDER BY) trên cột tỷ lệ thay vì cột năm.

Độ dài tối đa của chuỗi được trả về bởi GROUP_CONCAT bị giới hạn, do đó, chuỗi này hoạt động tốt nếu bạn cần chọn một vài bản ghi cho mỗi nhóm.

^{Các truy vấn ban đầu sử dụng biến người dùng và ORDER BYtrên bảng có nguồn gốc; hành vi của cả hai quirks không được đảm bảo. Sửa lại câu trả lời như sau.}

Trong MySQL 5.x, bạn có thể sử dụng thứ hạng của người nghèo trên phân vùng để đạt được kết quả mong muốn. Chỉ cần tham gia bên ngoài bảng với chính nó và cho mỗi hàng, đếm số lượng hàng ít hơn nó. Trong trường hợp trên, hàng nhỏ hơn là hàng có tỷ lệ cao hơn:

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

Demo và kết quả :

| id  | rate | year | rank |
|-----|------|------|------|
| p01 |  8.0 | 2006 | 0    |
| p01 |  7.4 | 2003 | 1    |
| p01 |  6.8 | 2008 | 2    |
| p01 |  5.9 | 2001 | 3    |
| p01 |  5.3 | 2007 | 4    |
| p02 | 12.5 | 2001 | 0    |
| p02 | 12.4 | 2004 | 1    |
| p02 | 12.2 | 2002 | 2    |
| p02 | 10.3 | 2003 | 3    |
| p02 |  8.7 | 2000 | 4    |

Lưu ý rằng nếu tỷ lệ có quan hệ, ví dụ:

100, 90, 90, 80, 80, 80, 70, 60, 50, 40, ...

Truy vấn trên sẽ trả về 6 hàng:

100, 90, 90, 80, 80, 80

Thay đổi để HAVING COUNT(DISTINCT l.rate) < 5có 8 hàng:

100, 90, 90, 80, 80, 80, 70, 60

Hoặc thay đổi để ON t.id = l.id AND (t.rate < l.rate OR (t.rate = l.rate AND t.pri_key > l.pri_key))có 5 hàng:

 100, 90, 90, 80, 80

Trong MySQL 8 hay muộn chỉ cần sử dụng RANK, DENSE_RANKhoặcROW_NUMBER chức năng:

SELECT *
FROM (
    SELECT *, RANK() OVER (PARTITION BY id ORDER BY rate DESC) AS rnk
    FROM t
) AS x
WHERE rnk <= 5

Đối với tôi một cái gì đó như

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

hoạt động hoàn hảo. Không có truy vấn phức tạp.

ví dụ: nhận top 1 cho mỗi nhóm

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;

Không, bạn không thể GIỚI HẠN các truy vấn con một cách tùy tiện (bạn có thể thực hiện nó ở một mức độ giới hạn trong các MySQL mới hơn, nhưng không cho 5 kết quả cho mỗi nhóm).

Đây là một truy vấn loại tối đa theo nhóm, không phải là chuyện nhỏ trong SQL. Có nhiều cách khác nhau để giải quyết vấn đề có thể hiệu quả hơn trong một số trường hợp, nhưng đối với top-n nói chung, bạn sẽ muốn xem câu trả lời của Bill cho một câu hỏi tương tự trước đó.

Như với hầu hết các giải pháp cho vấn đề này, nó có thể trả về hơn năm hàng nếu có nhiều hàng có cùng rategiá trị, vì vậy bạn vẫn có thể cần một số lượng xử lý hậu kỳ để kiểm tra xem.

Điều này đòi hỏi một loạt các truy vấn con để xếp hạng các giá trị, giới hạn chúng, sau đó thực hiện tổng trong khi nhóm

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

Thử cái này:

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;

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

Truy vấn con gần giống với truy vấn của bạn. Chỉ thay đổi là thêm

row_number() over (partition by id order by rate DESC)

Xây dựng các cột ảo （như RowID trong Oracle

bàn:

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

dữ liệu:

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 như thế này:

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;

nếu xóa mệnh đề where trong t3, nó sẽ hiển thị như sau:

NHẬN "Bản ghi TOP N" -> thêm "rownum <= 3" vào mệnh đề where (mệnh đề where của t3);

CHỌN "năm" -> thêm "GIỮA 2000 VÀ 2009" trong mệnh đề where (mệnh đề where của t3);

Đã làm một số công việc, nhưng tôi nghĩ rằng giải pháp của tôi sẽ là một cái gì đó để chia sẻ vì nó có vẻ thanh lịch cũng như khá nhanh.

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

Lưu ý rằng ví dụ này được chỉ định cho mục đích của câu hỏi và có thể được sửa đổi khá dễ dàng cho các mục đích tương tự khác.

Bài đăng sau: sql: selcting bản ghi N hàng đầu cho mỗi nhóm mô tả cách phức tạp để đạt được điều này mà không cần truy vấn con.

Nó cải thiện các giải pháp khác được cung cấp ở đây bằng cách:

• Làm mọi thứ trong một truy vấn duy nhất
• Có thể sử dụng đúng chỉ mục
• Tránh các truy vấn con, nổi tiếng là tạo ra các kế hoạch thực hiện xấu trong MySQL

Tuy nhiên nó không đẹp. Một giải pháp tốt sẽ có thể đạt được là Hàm cửa sổ (còn gọi là Hàm phân tích) được bật trong MySQL - nhưng chúng không có. Thủ thuật được sử dụng trong bài viết nói trên sử dụng GROUP_CONCAT, đôi khi được mô tả là "Các chức năng cửa sổ của người nghèo cho MySQL".

cho những người như tôi đã hết thời gian truy vấn. Tôi đã thực hiện dưới đây để sử dụng các giới hạn và bất cứ điều gì khác bởi một nhóm cụ thể.

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

nó lặp qua một danh sách các tên miền và sau đó chỉ chèn một giới hạn 200 mỗi tên miền

Thử cái này:

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;

Vui lòng thử bên dưới thủ tục lưu trữ. Tôi đã xác minh rồi. Tôi đang nhận được kết quả thích hợp nhưng không sử dụng 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