In SQL, come puoi "raggruppare per" negli intervalli?

Supponiamo che io abbia una tabella con una colonna numerica (chiamiamola "punteggio").

Vorrei generare una tabella di conteggi, che mostra quante volte i punteggi sono apparsi in ciascun intervallo.

Per esempio:

intervallo di punteggio | numero di occorrenze
-------------------------------------
   0-9 | 11
  10-19 | 14
  20-29 | 3
   ... | ...

In questo esempio c'erano 11 righe con punteggi nell'intervallo da 0 a 9, 14 righe con punteggi nell'intervallo da 10 a 19 e 3 righe con punteggi nell'intervallo 20-29.

C'è un modo semplice per configurarlo? Che cosa mi consiglia?

Nessuna delle risposte più votate è corretta su SQL Server 2000. Forse utilizzavano una versione diversa.

Ecco le versioni corrette di entrambi su SQL Server 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

o

select t.range as [score range], count(*) as [number of occurrences]
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

Un approccio alternativo implicherebbe l'archiviazione degli intervalli in una tabella, anziché incorporarli nella query. Si finirebbe con un tavolo, lo si chiama Ranges, che assomiglia a questo:

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

E una query simile a questa:

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

Ciò significa impostare una tabella, ma sarebbe facile da mantenere quando cambiano gli intervalli desiderati. Non sono necessarie modifiche al codice!

Vedo qui delle risposte che non funzioneranno nella sintassi di SQL Server. Io userei:

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: vedi commenti

In postgres (dove si ||trova l'operatore di concatenazione delle stringhe):

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

dà:

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

La risposta di James Curran è stata la più concisa secondo me, ma l'output non è corretto. Per SQL Server l'istruzione più semplice è la seguente:

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

Questo presuppone una tabella temporanea #Scores che ho usato per testarlo, ho appena popolato 100 righe con un numero casuale compreso tra 0 e 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

Ciò consentirà di non dover specificare intervalli e dovrebbe essere indipendente dal server SQL. Math FTW!

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

Lo farei in modo leggermente diverso in modo da ridimensionarlo senza dover definire tutti i casi:

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

Non testato, ma ti viene l'idea ...

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

Assicurati di usare una parola diversa da "range" se ti trovi in ​​MySQL, oppure visualizzerai un errore per l'esecuzione dell'esempio precedente.

Poiché la colonna ordinata su ( Range) è una stringa, viene utilizzato l'ordinamento stringa / parola anziché ordinamento numerico.

Fintanto che le stringhe hanno zeri per riempire le lunghezze dei numeri, l'ordinamento dovrebbe essere semanticamente corretto:

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

Se l'intervallo è misto, basta aggiungere un ulteriore 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

Provare

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;

Forse stai chiedendo di mantenere queste cose in corso ...

Ovviamente invocherai una scansione completa della tabella per le query e se la tabella contenente i punteggi che devono essere conteggiati (aggregazioni) è grande, potresti desiderare una soluzione con prestazioni migliori, puoi creare una tabella secondaria e utilizzare regole, come on insert- potresti guardarci dentro.

Tuttavia, non tutti i motori RDBMS hanno regole!