Oracle: comment “groupe” sur une plage?

SELECT CASE 
         WHEN age <= 10 THEN '1-10' 
         WHEN age <= 20 THEN '11-20' 
         ELSE '21+' 
       END AS age, 
       COUNT(*) AS n
FROM age
GROUP BY CASE 
           WHEN age <= 10 THEN '1-10' 
           WHEN age <= 20 THEN '11-20' 
           ELSE '21+' 
         END

Ce que vous cherchez, est à la base de données pour un histogramme.

Vous aurait l'âge (ou l'âge de gamme) sur l'axe des x et le nombre n (ou la fréquence) sur l'axe des y.

Dans la forme la plus simple, on pourrait simplement compter le nombre de chaque âge distinct de la valeur comme vous avez déjà décrites:

SELECT age, count(*)
FROM tbl
GROUP BY age

Quand il y a trop de valeurs pour l'axe des x cependant, on peut vouloir créer des groupes (ou clusters ou des seaux). Dans votre cas, vous groupe par une constante de gamme de 10.

Nous pouvons éviter d'écrire un WHEN ... THEN ligne pour chaque gamme, il pourrait y avoir des centaines, si ce n'était pas une question d'âge. Au lieu de cela, l'approche par @MatthewFlaschen est préférable pour les raisons mentionnées par @NitinMidha.

Maintenant nous allons créer le SQL...

Tout d'abord, nous avons besoin de diviser les âges dans la gamme de groupes de 10 comme suit:

• 0-9
• 10-19
• 20 - 29
• etc.

Ceci peut être obtenu en divisant la colonne âge par 10, puis à calculer le résultat de l'ÉTAGE:

FLOOR(age/10)

"ÉTAGE retourne le plus grand entier inférieur ou égal à celui n"
http://docs.oracle.com/cd/E11882_01/server.112/e26088/functions067.htm#SQLRF00643

Puis nous prenons la version d'origine de SQL et de les remplacer âge avec cette expression:

SELECT FLOOR(age/10), count(*)
FROM tbl
GROUP BY FLOOR(age/10)

C'est OK, mais nous ne pouvons pas voir la gamme, encore. Au lieu de cela on ne voit que le calcul de plancher des valeurs qui sont 0, 1, 2 ... n.

D'obtenir le véritable borne inférieure, nous avons besoin de le multiplier avec 10 de nouveau afin d'obtenir 0, 10, 20 ... n:

FLOOR(age/10) * 10

Nous avons aussi besoin de la limite supérieure de chaque plage est inférieur lié + 10 - 1 ou

FLOOR(age/10) * 10 + 10 - 1

Enfin, nous concaténer les deux dans une chaîne de caractères comme ceci:

TO_CHAR(FLOOR(age/10) * 10) || '-' || TO_CHAR(FLOOR(age/10) * 10 + 10 - 1)

Cela crée '0-9', '10-19', '20-29' etc.

Maintenant notre SQL ressemble à ceci:

SELECT 
TO_CHAR(FLOOR(age/10) * 10) || ' - ' || TO_CHAR(FLOOR(age/10) * 10 + 10 - 1),
COUNT(*)
FROM tbl
GROUP BY FLOOR(age/10)

Enfin, appliquer une commande et de nice les alias de colonne:

SELECT 
TO_CHAR(FLOOR(age/10) * 10) || ' - ' || TO_CHAR(FLOOR(age/10) * 10 + 10 - 1) AS range,
COUNT(*) AS frequency
FROM tbl
GROUP BY FLOOR(age/10)
ORDER BY FLOOR(age/10)

Toutefois, dans des scénarios plus complexes, ces plages peuvent pas être regroupés en constante morceaux de taille 10, mais besoin de clustering dynamique.
Oracle est plus avancée de l'histogramme pour les fonctions, voir http://docs.oracle.com/cd/E16655_01/server.121/e15858/tgsql_histo.htm#TGSQL366

Crédits à @MatthewFlaschen pour son approche; j'ai seulement expliqué les détails.

J'ai eu de groupe de données par le nombre de transactions est apparu dans une heure. Je l'ai fait par l'extraction de l'heure de l'horodatage:

select extract(hour from transaction_time) as hour
      ,count(*)
from   table
where  transaction_date='01-jan-2000'
group by
       extract(hour from transaction_time)
order by
       extract(hour from transaction_time) asc
;

Donner de sortie:

HOUR COUNT(*)
---- --------
   1     9199 
   2     9167 
   3     9997 
   4     7218

Comme vous pouvez le voir, ce qui donne un joli moyen facile de regroupement, le nombre d'enregistrements par heure.

Si vous utilisez Oracle 9i+, vous pourrait être en mesure d'utiliser le NTILE analytique de la fonction:

WITH tiles AS (
  SELECT t.age,
         NTILE(3) OVER (ORDER BY t.age) AS tile
    FROM TABLE t)
  SELECT MIN(t.age) AS min_age,
         MAX(t.age) AS max_age,
         COUNT(t.tile) As n
    FROM tiles t
GROUP BY t.tile

La mise en garde à NTILE, c'est que vous ne pouvez spécifier que le nombre de partitions, pas les points de rupture eux-mêmes. Si vous avez besoin de spécifier un nombre approprié. C'est à dire: Avec 100 lignes, NTILE(4) attribuera 25 lignes pour chacun des quatre compartiments/partitions. Vous ne pouvez pas imbriquer les fonctions analytiques, de sorte que vous auriez à les superposer à l'aide de sous-requêtes/sous-requête d'affacturage pour obtenir granularité souhaitée. Sinon, utilisez:

  SELECT CASE t.age
           WHEN BETWEEN 1 AND 10 THEN '1-10' 
           WHEN BETWEEN 11 AND 20 THEN '11-20' 
           ELSE '21+' 
         END AS age, 
         COUNT(*) AS n
    FROM TABLE t
GROUP BY CASE t.age
           WHEN BETWEEN 1 AND 10 THEN '1-10' 
           WHEN BETWEEN 11 AND 20 THEN '11-20' 
           ELSE '21+' 
         END

Mon approche:

select range, count(1) from (
select case 
  when age < 5 then '0-4' 
  when age < 10 then '5-9' 
  when age < 15 then '10-14' 
  when age < 20 then '15-20' 
  when age < 30 then '21-30' 
  when age < 40 then '31-40' 
  when age < 50 then '41-50' 
  else                '51+' 
end 
as range from
(select round(extract(day from feedback_update_time - feedback_time), 1) as age
from txn_history
) ) group by range  

• J'ai flexibilité dans la définition des gammes de
• Je n'ai pas répéter les gammes de sélectionner et regrouper des clauses
• mais quelqu'un s'il vous plaît dites-moi, comment les classer par ordre de grandeur!