W SQL, jak można "grupować" w zakresach?

Alternatywne podejście obejmowałoby przechowywanie zakresów w tabeli, zamiast osadzania ich w zapytaniu. Można by skończyć tabelą, nazywając ją zakresami, która wygląda tak:

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 będzie ona łatwa do utrzymania, gdy pożądane zakresy ulegną zmianie. Nie trzeba wprowadzać zmian w kodzie!

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

EDIT: Zobacz komentarze

W postgres (gdzie || jest operatorem konkatenacji łańcuchowej):

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

ODPOWIEDŹ Jamesa Currana była najbardziej zwięzła moim zdaniem, ale wynik nie był poprawny. Dla SQL Server najprostsze polecenie jest następujące:

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

To zakłada tymczasową tabelę # Scores, której użyłem do testowania, po prostu wypełniłem 100 wierszy z 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 określać zakresów i powinno być niezależne od SQL server. Matma FTW!

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

Zrobiłbym to trochę inaczej, aby skalowało się 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 testowane, 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ż 'range', jeśli jesteś w MySQL, w przeciwnym razie pojawi się błąd podczas uruchamiania powyższego przykładu.

Ponieważ kolumna sortowana na (Range) jest łańcuchem znaków, sortowanie łańcuchów / słów jest używane zamiast sortowania numerycznego.

Tak długo, jak ciągi znaków mają zera do wyprowadzania długości liczb, sortowanie powinno być nadal poprawne semantycznie:

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

Try

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;

select t.range as score, count(*) as Count 
from (
      select UserId,
         case when isnull(score ,0) >= 0 and isnull(score ,0)< 5 then '0-5'
                when isnull(score ,0) >= 5 and isnull(score ,0)< 10 then '5-10'
                when isnull(score ,0) >= 10 and isnull(score ,0)< 15 then '10-15'
                when isnull(score ,0) >= 15 and isnull(score ,0)< 20 then '15-20'               
         else ' 20+' end as range
         ,case when isnull(score ,0) >= 0 and isnull(score ,0)< 5 then 1
                when isnull(score ,0) >= 5 and isnull(score ,0)< 10 then 2
                when isnull(score ,0) >= 10 and isnull(score ,0)< 15 then 3
                when isnull(score ,0) >= 15 and isnull(score ,0)< 20 then 4             
         else 5  end as pd
     from score table
     ) t

group by t.range,pd order by pd

Jestem tutaj, ponieważ mam podobne pytanie, ale uważam, że krótkie odpowiedzi są błędne, a ta z ciągłym "przypadkiem, gdy" jest dużo pracy i widząc coś powtarzającego się w moim kodzie, rani moje oczy. Oto rozwiązanie

SELECT --MIN(score), MAX(score),
    [score range] = CAST(ROUND(score-5,-1)AS VARCHAR) + ' - ' + CAST((ROUND(score-5,-1)+10)AS VARCHAR),
    [number of occurrences] = COUNT(*)
FROM order
GROUP BY  CAST(ROUND(score-5,-1)AS VARCHAR) + ' - ' + CAST((ROUND(score-5,-1)+10)AS VARCHAR)
ORDER BY MIN(score)

Być może pytasz o utrzymanie tego typu rzeczy...

Oczywiście wywołasz Pełne skanowanie tabeli w poszukiwaniu zapytań i jeśli tabela zawierająca wyniki, które muszą być obliczone (agregacje)jest duża, możesz chcieć lepszego rozwiązania, możesz utworzyć tabelę drugorzędną i użyć reguł, takich jak on insert - możesz to sprawdzić.