Wybierz 10 najlepszych rekordów dla każdej kategorii

Chcę zwrócić 10 najlepszych rekordów z każdej sekcji w jednym zapytaniu. Czy ktoś może pomóc w tym, jak to zrobić? Sekcja jest jedną z kolumn w tabeli.

Bazą danych jest SQL Server 2005. Chcę zwrócić 10 najlepszych według wprowadzonej daty. Sekcje są biznesowe, lokalne i funkcjonalne. Dla jednej konkretnej daty chcę tylko górne (10) wierszy biznesowych (najnowszy wpis), górne (10) wierszy lokalnych i górne (10) funkcji.

Jeśli używasz SQL 2005, możesz zrobić coś takiego ...

SELECT rs.Field1,rs.Field2 
    FROM (
        SELECT Field1,Field2, Rank() 
          over (Partition BY Section
                ORDER BY RankCriteria DESC ) AS Rank
        FROM table
        ) rs WHERE Rank <= 10

Jeśli twoje RankCriteria ma powiązania, możesz zwrócić więcej niż 10 rzędów, a rozwiązanie Matta może być dla Ciebie lepsze.

W T-SQL zrobiłbym:

WITH TOPTEN AS (
    SELECT *, ROW_NUMBER() 
    over (
        PARTITION BY [group_by_field] 
        order by [prioritise_field]
    ) AS RowNo 
    FROM [table_name]
)
SELECT * FROM TOPTEN WHERE RowNo <= 10

Działa to na SQL Server 2005 (edytowany w celu odzwierciedlenia twoich wyjaśnień):

select *
from Things t
where t.ThingID in (
    select top 10 ThingID
    from Things tt
    where tt.Section = t.Section and tt.ThingDate = @Date
    order by tt.DateEntered desc
    )
    and t.ThingDate = @Date
order by Section, DateEntered desc

SELECT r.*
FROM
(
    SELECT
        r.*,
        ROW_NUMBER() OVER(PARTITION BY r.[SectionID] ORDER BY r.[DateEntered] DESC) rn
    FROM [Records] r
) r
WHERE r.rn <= 10
ORDER BY r.[DateEntered] DESC

Robię to w ten sposób:

SELECT a.* FROM articles AS a
  LEFT JOIN articles AS a2 
    ON a.section = a2.section AND a.article_date <= a2.article_date
GROUP BY a.article_id
HAVING COUNT(*) <= 10;

aktualizacja: Ten przykład GROUP BY działa tylko w MySQL i SQLite, ponieważ te bazy danych są bardziej liberalne niż standardowy SQL dotyczący GROUP BY. Większość implementacji SQL wymaga, aby wszystkie kolumny na liście wyboru, które nie są częścią wyrażenia agregującego, również znajdowały się w grupie GROUP BY.

Jeśli użyjemy SQL Server> = 2005, możemy rozwiązać zadanie za pomocą tylko jednego wyboru :

declare @t table (
    Id      int ,
    Section int,
    Moment  date
);

insert into @t values
(   1   ,   1   , '2014-01-01'),
(   2   ,   1   , '2014-01-02'),
(   3   ,   1   , '2014-01-03'),
(   4   ,   1   , '2014-01-04'),
(   5   ,   1   , '2014-01-05'),

(   6   ,   2   , '2014-02-06'),
(   7   ,   2   , '2014-02-07'),
(   8   ,   2   , '2014-02-08'),
(   9   ,   2   , '2014-02-09'),
(   10  ,   2   , '2014-02-10'),

(   11  ,   3   , '2014-03-11'),
(   12  ,   3   , '2014-03-12'),
(   13  ,   3   , '2014-03-13'),
(   14  ,   3   , '2014-03-14'),
(   15  ,   3   , '2014-03-15');


-- TWO earliest records in each Section

select top 1 with ties
    Id, Section, Moment 
from
    @t
order by 
    case 
        when row_number() over(partition by Section order by Moment) <= 2 
        then 0 
        else 1 
    end;


-- THREE earliest records in each Section

select top 1 with ties
    Id, Section, Moment 
from
    @t
order by 
    case 
        when row_number() over(partition by Section order by Moment) <= 3 
        then 0 
        else 1 
    end;


-- three LATEST records in each Section

select top 1 with ties
    Id, Section, Moment 
from
    @t
order by 
    case 
        when row_number() over(partition by Section order by Moment desc) <= 3 
        then 0 
        else 1 
    end;

Jeśli wiesz, jakie są sekcje, możesz:

select top 10 * from table where section=1
union
select top 10 * from table where section=2
union
select top 10 * from table where section=3

Wiem, że ten wątek jest trochę stary, ale właśnie wpadłem na podobny problem (wybierz najnowszy artykuł z każdej kategorii) i oto rozwiązanie, które wymyśliłem:

WITH [TopCategoryArticles] AS (
    SELECT 
        [ArticleID],
        ROW_NUMBER() OVER (
            PARTITION BY [ArticleCategoryID]
            ORDER BY [ArticleDate] DESC
        ) AS [Order]
    FROM [dbo].[Articles]
)
SELECT [Articles].* 
FROM 
    [TopCategoryArticles] LEFT JOIN 
    [dbo].[Articles] ON
        [TopCategoryArticles].[ArticleID] = [Articles].[ArticleID]
WHERE [TopCategoryArticles].[Order] = 1

Jest to bardzo podobne do rozwiązania Darrela, ale rozwiązuje problem RANK, który może zwrócić więcej wierszy niż planowano.

Próbowałem następujących rzeczy i to również działało z więzami.

SELECT rs.Field1,rs.Field2 
FROM (
    SELECT Field1,Field2, ROW_NUMBER() 
      OVER (Partition BY Section
            ORDER BY RankCriteria DESC ) AS Rank
    FROM table
    ) rs WHERE Rank <= 10

Jeśli chcesz produkować wyniki pogrupowane według sekcji, wyświetlając tylko górne n rekordów z każdej sekcji mniej więcej tak:

SECTION     SUBSECTION

deer        American Elk/Wapiti
deer        Chinese Water Deer
dog         Cocker Spaniel
dog         German Shephard
horse       Appaloosa
horse       Morgan

... to poniższe powinny działać dość ogólnie ze wszystkimi bazami danych SQL. Jeśli chcesz 10 najlepszych, po prostu zmień 2 na 10 pod koniec zapytania.

select
    x1.section
    , x1.subsection
from example x1
where
    (
    select count(*)
    from example x2
    where x2.section = x1.section
    and x2.subsection <= x1.subsection
    ) <= 2
order by section, subsection;

Ustawić:

create table example ( id int, section varchar(25), subsection varchar(25) );

insert into example select 0, 'dog', 'Labrador Retriever';
insert into example select 1, 'deer', 'Whitetail';
insert into example select 2, 'horse', 'Morgan';
insert into example select 3, 'horse', 'Tarpan';
insert into example select 4, 'deer', 'Row';
insert into example select 5, 'horse', 'Appaloosa';
insert into example select 6, 'dog', 'German Shephard';
insert into example select 7, 'horse', 'Thoroughbred';
insert into example select 8, 'dog', 'Mutt';
insert into example select 9, 'horse', 'Welara Pony';
insert into example select 10, 'dog', 'Cocker Spaniel';
insert into example select 11, 'deer', 'American Elk/Wapiti';
insert into example select 12, 'horse', 'Shetland Pony';
insert into example select 13, 'deer', 'Chinese Water Deer';
insert into example select 14, 'deer', 'Fallow';

Czy operator UNION może dla ciebie pracować? Posiadaj jeden WYBÓR dla każdej sekcji, a następnie ZJEDNOCZENIE je razem. Chyba zadziałałoby to tylko dla określonej liczby sekcji.

Q) Wyszukiwanie rekordów TOP X z każdej grupy (Oracle)

SQL> select * from emp e 
  2  where e.empno in (select d.empno from emp d 
  3  where d.deptno=e.deptno and rownum<3)
  4  order by deptno
  5  ;

 EMPNO ENAME      JOB              MGR HIREDATE         SAL       COMM     DEPTNO

  7782 CLARK      MANAGER         7839 09-JUN-81       2450                    10
  7839 KING       PRESIDENT            17-NOV-81       5000                    10
  7369 SMITH      CLERK           7902 17-DEC-80        800                    20
  7566 JONES      MANAGER         7839 02-APR-81       2975                    20
  7499 ALLEN      SALESMAN        7698 20-FEB-81       1600        300         30
  7521 WARD       SALESMAN        7698 22-FEB-81       1250        500         30

Wybrano 6 wierszy.

Chociaż pytanie dotyczyło programu SQL Server 2005, większość ludzi przeszło do przodu i jeśli znajdzie to pytanie, w innych sytuacjach preferowaną odpowiedzią jest skorzystanie z niego, CROSS APPLYjak pokazano w tym poście na blogu .

SELECT *
FROM t
CROSS APPLY (
  SELECT TOP 10 u.*
  FROM u
  WHERE u.t_id = t.t_id
  ORDER BY u.something DESC
) u

To zapytanie obejmuje 2 tabele. Zapytanie OP dotyczy tylko 1 tabeli, w przypadku której rozwiązanie oparte na funkcji okna może być bardziej wydajne.

Możesz wypróbować to podejście. To zapytanie zwraca 10 najbardziej zaludnionych miast dla każdego kraju.

   SELECT city, country, population
   FROM
   (SELECT city, country, population, 
   @country_rank := IF(@current_country = country, @country_rank + 1, 1) AS country_rank,
   @current_country := country 
   FROM cities
   ORDER BY country, population DESC
   ) ranked
   WHERE country_rank <= 10;