Dalam SQL, bagaimana Anda bisa "mengelompokkan" dalam rentang?

Misalkan saya memiliki tabel dengan kolom numerik (sebut saja "skor").

Saya ingin menghasilkan tabel hitungan, yang menunjukkan berapa kali skor muncul di setiap rentang.

Sebagai contoh:

rentang skor | jumlah kejadian
-------------------------------------
   0-9 | 11
  10-19 | 14
  20-29 | 3
   ... | ...

Dalam contoh ini ada 11 baris dengan skor di kisaran 0 hingga 9, 14 baris dengan skor di kisaran 10 hingga 19, dan 3 baris dengan skor di kisaran 20-29.

Apakah ada cara mudah untuk mengatur ini? Apa yang kamu sarankan?

Tak satu pun dari jawaban pilihan tertinggi benar pada SQL Server 2000. Mungkin mereka menggunakan versi yang berbeda.

Berikut adalah versi yang benar dari keduanya di 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

atau

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

Pendekatan alternatif akan melibatkan menyimpan rentang dalam tabel, alih-alih menyematkannya dalam kueri. Anda akan berakhir dengan sebuah meja, sebut saja Ranges, yang terlihat seperti ini:

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

Dan permintaan yang terlihat seperti ini:

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

Ini berarti menyiapkan tabel, tetapi akan mudah untuk mempertahankannya ketika rentang yang diinginkan berubah. Tidak diperlukan perubahan kode!

Saya melihat jawaban di sini yang tidak akan berfungsi dalam sintaks SQL Server. Saya akan menggunakan:

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

Sunting: lihat komentar

Dalam postgres (di mana ||operator string concatenation):

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

memberi:

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

Jawaban James Curran adalah yang paling ringkas menurut saya, tetapi hasilnya tidak benar. Untuk SQL Server pernyataan paling sederhana adalah sebagai berikut:

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

Ini mengasumsikan tabel sementara #Scores yang saya gunakan untuk mengujinya, saya baru saja mengisi 100 baris dengan angka acak antara 0 dan 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

Ini akan memungkinkan Anda untuk tidak harus menentukan rentang, dan harus agnostik SQL server. FTW Matematika!

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

Saya akan melakukan ini sedikit berbeda sehingga skala tanpa harus mendefinisikan setiap kasus:

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

Tidak diuji, tetapi Anda mendapatkan idenya ...

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

Pastikan Anda menggunakan kata selain 'rentang' jika Anda menggunakan MySQL, atau Anda akan mendapatkan kesalahan saat menjalankan contoh di atas.

Karena kolom yang diurutkan pada ( Range) adalah string, pengurutan string / kata digunakan bukan pengurutan numerik.

Selama string memiliki nol untuk menambah panjang angka, penyortiran harus secara semantik benar:

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

Jika rentang tersebut dicampur, cukup masukkan nol tambahan:

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

Mencoba

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;

Mungkin Anda bertanya tentang menjaga hal-hal seperti itu berjalan ...

Tentu saja Anda akan meminta pemindaian tabel penuh untuk kueri dan jika tabel yang berisi skor yang perlu dihitung (agregasi) besar, Anda mungkin menginginkan solusi yang berkinerja lebih baik, Anda bisa membuat tabel sekunder dan menggunakan aturan, seperti on insert - Anda mungkin melihatnya.

Namun, tidak semua mesin RDBMS memiliki aturan!