transact - En SQL, ¿cómo se puede "agrupar por" en rangos?

transact sql pdf

Question

Supongamos que tengo una tabla con una columna numérica (digamos "puntuación").

Me gustaría generar una tabla de recuentos, que muestre cuántas veces aparecieron puntajes en cada rango.

Por ejemplo:

score range | number of occurrences ------------------------------------- 0-9 | 11 10-19 | 14 20-29 | 3 ... | ...

En este ejemplo, hubo 11 filas con puntajes en el rango de 0 a 9, 14 filas con puntajes en el rango de 10 a 19, y 3 filas con puntajes en el rango de 20-29.

¿Hay alguna manera fácil de configurar esto? ¿Que recomiendas?

Answer 1

Como la columna que se está ordenando ( Range ) es una cadena, se utiliza la clasificación de cadena / palabra en lugar de la clasificación numérica.

Siempre que las cadenas tengan ceros para rellenar las longitudes de los números, la clasificación debería ser semánticamente correcta:

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

Si el rango es mixto, simplemente rellene un cero adicional:

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

Answer 2

En postgres (donde || es el operador de concatenación de cadenas):

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

da:

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

Answer 3

Esto le permitirá no tener que especificar rangos, y debe ser SQL Server independiente. Matemáticas FTW!

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

Answer 4

Haría esto un poco diferente para que se escalara sin tener que definir cada caso:

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

No probado, pero entiendes la idea ...

Answer 5

La respuesta de James Curran fue la más concisa en mi opinión, pero la salida no fue correcta. Para SQL Server, la declaración más simple es la siguiente:

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

Esto supone una tabla temporal #Scores que utilicé para probarla, acabo de completar 100 filas con un número aleatorio entre 0 y 99.

Answer 6

Ninguna de las respuestas más votadas es correcta en SQLServer 2000. Quizás estaban usando una versión diferente.

Aquí están las versiones correctas de ambos en 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

o

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

Answer 7

Tal vez estás preguntando por mantener estas cosas en marcha ...

Por supuesto, invocará una exploración de tabla completa para las consultas y si la tabla que contiene los puntajes que deben ser contados (agregaciones) es grande, es posible que desee una solución de mejor rendimiento, puede crear una tabla secundaria y usar reglas, como on insert , puedes mirarlo.

Sin embargo, no todos los motores RDBMS tienen reglas.

Answer 8

Tratar

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;

Answer 9

Un enfoque alternativo implicaría almacenar los rangos en una tabla, en lugar de incrustarlos en la consulta. Usted terminaría con una tabla, llámala Rangos, que se ve así:

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

Y una consulta que se ve así:

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

Esto significa configurar una tabla, pero sería fácil de mantener cuando cambien los rangos deseados. ¡No es necesario cambiar el código!

Answer 10

Veo respuestas aquí que no funcionarán en la sintaxis de SQL Server. Yo usaría:

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

EDITAR: ver comentarios

Answer 11

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

Answer 12

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)

Answer 13

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

Answer 14

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

Asegúrese de utilizar una palabra que no sea ''rango'' si está en MySQL, o obtendrá un error al ejecutar el ejemplo anterior.