Jak w SQL można „grupować według” w zakresach?

Załóżmy, że mam tabelę z kolumną numeryczną (nazwijmy ją „wynikiem”).

Chciałbym wygenerować tabelę zliczeń, która pokazuje, ile razy wyniki pojawiły się w każdym zakresie.

Na przykład:

zakres punktacji | liczba wystąpień
-------------------------------------
   0–9 | 11
  10–19 | 14
  20–29 | 3)
   ... | ...

W tym przykładzie było 11 rzędów z wynikami w przedziale od 0 do 9, 14 rzędów z wynikami w przedziale od 10 do 19 oraz 3 rzędy z wynikami w przedziale 20-29.

Czy istnieje prosty sposób na skonfigurowanie tego? Co polecasz?

Żadna z najwyżej ocenianych odpowiedzi nie jest poprawna w SQLServer 2000. Być może używali innej wersji.

Oto poprawne wersje obu z nich na SQLServer 2000.

select t.range as [score range], count(*) as [number of occurences]
from (
  select case  
    when score between 0 and 9 then ' 0- 9'
    when score between 10 and 19 then '10-19'
    else '20-99' end as range
  from scores) t
group by t.range

lub

select t.range as [score range], count(*) as [number of occurences]
from (
      select user_id,
         case when score >= 0 and score< 10 then '0-9'
         when score >= 10 and score< 20 then '10-19'
         else '20-99' end as range
     from scores) t
group by t.range

Alternatywne podejście polegałoby na przechowywaniu zakresów w tabeli zamiast osadzania ich w zapytaniu. W efekcie powstałby stół, który nazywa się Ranges, który wygląda następująco:

LowerLimit   UpperLimit   Range 
0              9          '0-9'
10            19          '10-19'
20            29          '20-29'
30            39          '30-39'

I zapytanie, które wygląda tak:

Select
   Range as [Score Range],
   Count(*) as [Number of Occurences]
from
   Ranges r inner join Scores s on s.Score between r.LowerLimit and r.UpperLimit
group by Range

Oznacza to ustawienie tabeli, ale byłoby łatwe do utrzymania, gdy zmienią się pożądane zakresy. Żadne zmiany kodu nie są konieczne!

Widzę tutaj odpowiedzi, które nie będą działać w składni SQL Server. Użyłbym:

select t.range as [score range], count(*) as [number of occurences]
from (
  select case 
    when score between  0 and  9 then ' 0-9 '
    when score between 10 and 19 then '10-19'
    when score between 20 and 29 then '20-29'
    ...
    else '90-99' end as range
  from scores) t
group by t.range

EDYCJA: patrz komentarze

W postgres (gdzie ||jest operator konkatenacji ciągu):

select (score/10)*10 || '-' || (score/10)*10+9 as scorerange, count(*)
from scores
group by score/10
order by 1

daje:

 scorerange | count 
------------+-------
 0-9        |    11
 10-19      |    14
 20-29      |     3
 30-39      |     2

Moim zdaniem odpowiedź Jamesa Currana była najbardziej zwięzła, ale wyniki nie były prawidłowe. W przypadku SQL Server najprostsza instrukcja wygląda następująco:

SELECT 
    [score range] = CAST((Score/10)*10 AS VARCHAR) + ' - ' + CAST((Score/10)*10+9 AS VARCHAR), 
    [number of occurrences] = COUNT(*)
FROM #Scores
GROUP BY Score/10
ORDER BY Score/10

Zakłada się, że tymczasową tabelę #Scores użyłem do jej przetestowania, właśnie zapełniłem 100 wierszy losową liczbą od 0 do 99.

create table scores (
   user_id int,
   score int
)

select t.range as [score range], count(*) as [number of occurences]
from (
      select user_id,
         case when score >= 0 and score < 10 then '0-9'
         case when score >= 10 and score < 20 then '10-19'
         ...
         else '90-99' as range
     from scores) t
group by t.range

select cast(score/10 as varchar) + '-' + cast(score/10+9 as varchar), 
       count(*)
from scores
group by score/10

To pozwoli ci nie musieć określać zakresów i powinno być agnostyczne dla serwera SQL. Matematyka FTW!

SELECT CONCAT(range,'-',range+9), COUNT(range)
FROM (
  SELECT 
    score - (score % 10) as range
  FROM scores
)

Zrobiłbym to trochę inaczej, aby skalować bez konieczności definiowania każdego przypadku:

select t.range as [score range], count(*) as [number of occurences]
from (
  select FLOOR(score/10) as range
  from scores) t
group by t.range

Nie testowano, ale masz pomysł ...

declare @RangeWidth int

set @RangeWidth = 10

select
   Floor(Score/@RangeWidth) as LowerBound,
   Floor(Score/@RangeWidth)+@RangeWidth as UpperBound,
   Count(*)
From
   ScoreTable
group by
   Floor(Score/@RangeWidth)

select t.blah as [score range], count(*) as [number of occurences]
from (
  select case 
    when score between  0 and  9 then ' 0-9 '
    when score between 10 and 19 then '10-19'
    when score between 20 and 29 then '20-29'
    ...
    else '90-99' end as blah
  from scores) t
group by t.blah

Upewnij się, że używasz słowa innego niż „zakres”, jeśli jesteś w MySQL, w przeciwnym razie wystąpi błąd podczas uruchamiania powyższego przykładu.

Ponieważ sortowana kolumna ( Range) jest ciągiem, zamiast sortowania numerycznego stosuje się sortowanie ciągów / słów.

Tak długo, jak ciągi mają zera zerujące długości liczb, sortowanie powinno być semantycznie poprawne:

SELECT t.range AS ScoreRange,
       COUNT(*) AS NumberOfOccurrences
  FROM (SELECT CASE
                    WHEN score BETWEEN 0 AND 9 THEN '00-09'
                    WHEN score BETWEEN 10 AND 19 THEN '10-19'
                    ELSE '20-99'
               END AS Range
          FROM Scores) t
 GROUP BY t.Range

Jeśli zakres jest mieszany, po prostu wstaw dodatkowe zero:

SELECT t.range AS ScoreRange,
       COUNT(*) AS NumberOfOccurrences
  FROM (SELECT CASE
                    WHEN score BETWEEN 0 AND 9 THEN '000-009'
                    WHEN score BETWEEN 10 AND 19 THEN '010-019'
                    WHEN score BETWEEN 20 AND 99 THEN '020-099'
                    ELSE '100-999'
               END AS Range
          FROM Scores) t
 GROUP BY t.Range

Próbować

SELECT (str(range) + "-" + str(range + 9) ) AS [Score range], COUNT(score) AS [number of occurances]
FROM (SELECT  score,  int(score / 10 ) * 10  AS range  FROM scoredata )  
GROUP BY range;

Być może pytasz o utrzymanie takich rzeczy ...

Oczywiście będziesz wywoływać pełne skanowanie tabeli dla zapytań, a jeśli tabela zawierająca wyniki, które muszą zostać zebrane (agregacje) jest duża, możesz chcieć rozwiązania o lepszej wydajności, możesz utworzyć tabelę pomocniczą i zastosować reguły, takie jak on insert- możesz na to spojrzeć.

Jednak nie wszystkie silniki RDBMS mają reguły!