La façon de calculer le pourcentage d'une instruction SQL

J'ai une table SQL Server qui contient les utilisateurs & leurs notes. Pour des raisons de simplicité, permet de dire il y a 2 colonnes - name & grade. Donc, typique de la ligne serait le Nom de "John Doe", Nuance:"Un".

Je suis à la recherche d'une instruction SQL qui vous permettra de trouver les pourcentages de toutes les réponses possibles. (A, B, C, etc...) Aussi, est-il un moyen de le faire sans que la définition de l'ensemble des réponses possibles (ouvrir le champ de texte - les utilisateurs pourraient entrer en "pass/fail', 'none', etc...)

La sortie finale, je suis à la recherche d'Un: 5%, B: 15%, C: 40%, etc...

InformationsquelleAutor Alex | 2009-04-21

216

J'ai testé le suivant et cela fonctionne. La réponse par gordyii était proche, mais avait la multiplication des 100 au mauvais endroit et a eu quelques parenthèse manquante.
```
Select Grade, (Count(Grade)* 100 / (Select Count(*) From MyTable)) as Score
From MyTable
Group By Grade
```
- cela donne suite des nombres entiers .somme des résultats n'est pas égal à 100.
- Pas le plus efficace que la table est analysé deux fois. Aussi la requête a pas l'air si simple, si il n'y a plus d'une table référencée.
- vous pouvez changer 100 à 100,0 pour les valeurs décimales.
- Quelqu'un peut m'expliquer pourquoi les mathématiques de la syntaxe de la requête SQL n'est pas ce que vous attendez pour le faire normalement? Par exemple normal j'aurais divisé par le total des temps, puis par 100? Vraiment curieux à propos de cette logique au point.
- 2) / 4 = 50, (2/4) * 100 = 50 aussi longtemps que l'agent recenseur est est la partie d'être multiplié. En raison de la priorité d'instructions SQL, ce sera la même. toutefois, en raison de types de données si vous utilisez 100, vous pouvez toujours obtenir le résultat arrondi à 0 décimales que vous désirez pour l' % si vous la mettre après la division de l'opération, vous devez vous assurer que vous lancez à un type de données permettant de gérer les décimales sinon vous allez vous retrouver avec 100 ou 0 et jamais un pourcentage réel
- Merci pour la réponse, qui fait sens, et je pense que la partie sur les types de données ayant pour support des décimales est à l'origine m'a jeté, parce que je n'ai pas précisé les contraintes de types de données dans ma pensée, donc dans ma tête c'était un peu étrange.
- la solution c'est bon, mais vous devez prendre en compte le fait que le diviseur peut être 0 si la table est vide et que jeter une erreur
- Quelque part, cette solution n'a pas donner la somme de 100 à la fin. J'ai tenté de changer les valeurs décimales ainsi. À l'aide de @jean-gibb 's réponse renvoie 100. Je ne sais pas pourquoi
InformationsquelleAutor Jason
200
1. La plus efficace (à l'aide de plus()).
```
select Grade, count(*) * 100.0 / sum(count(*)) over()
from MyTable
group by Grade
```
2. Universelle (toute version SQL).
```
select Grade, count(*) * 100.0 / (select count(*) from MyTable)
from MyTable
group by Grade;
```
3. Avec CTE, la moins efficace.
```
with t(Grade, GradeCount) 
as 
( 
    select Grade, count(*) 
    from MyTable
    group by Grade
)
select Grade, GradeCount * 100.0/(select sum(GradeCount) from t)
from t;
```
- plus de() a parfaitement fonctionné sur mon Serveur SQL server 2008, j'ai fait le calcul pour confirmer. Afin de l'arrondir à 2 décimales j'ai utilisé CAST(count() * 100.0 / somme(count)) sur() COMME séparateur DÉCIMAL(18, 2)). Merci pour le post!
- En cas de débordement sur les 100 de multiplication (par exemple, erreur de dépassement Arithmétique expression de conversion de type de données int), le remplacer avec la division en dénominateur plutôt: cast((count(*) / (sum(count(*)) over() / 100)) AS DECIMAL(18, 2)) as Percentage
- Pourquoi avez-vous avoir à multiplier par 100.0 et pas seulement 100 lorsque vous êtes à la coulée de la sortie comme un nombre décimal?
- car la conversion de décimal qui se passe APRÈS l'opération de division. Si vous laissez un int (100), la division par un autre int entraînera dans un int, ce qui arrondit le résultat. C'est pourquoi l'astuce est de toujours forcer un cast sur le dividende avant la division (vous pouvez multiplier par un littéral décimal comme 1.0 ou cast/convertir)
- Option 1 avec over() fonctionne très bien sur Postgresql 10
InformationsquelleAutor Alex Aza
38

Au lieu de séparer les CTE pour obtenir le total, vous pouvez utiliser une fonction de fenêtre sans la "partition par une clause".

Si vous utilisez:
```
count(*)
```
pour obtenir le nombre d'un groupe, vous pouvez utiliser:
```
sum(count(*)) over ()
```
pour obtenir le nombre total d'.

Par exemple:
```
select Grade, 100. * count(*) / sum(count(*)) over ()
from table
group by Grade;
```
Il a tendance à être plus rapide dans mon expérience, mais je pense qu'il pourrait utiliser à l'interne d'une table temporaire dans certains cas (j'ai vu la "table de travail" lors de l'exécution avec "set statistics io on").

EDIT:
Je ne sais pas si mon exemple de requête est ce que vous cherchez, j'étais juste en illustrant la façon dont les fonctions de fenêtrage de travail.
- +1. Ce qui est excellent. Il peut également être utilisé si à la place de "table" il y a une instruction select.
- Il utilise une bobine dans tempdb qui est la table de travail. Les lectures logiques semblent plus élevé mais ils sont comptés différemment
- En fait, la COUNT(*) OVER () dans votre requête retourne complètement sans rapport avec la figure (plus précisément, le nombre de lignes de la regroupés jeu de résultats). Vous devez utiliser SUM(COUNT(*)) OVER () à la place.
InformationsquelleAutor John Gibb
9

Vous devez calculer le total des notes
Si c'est SQL 2005, vous pouvez utiliser CTE
```
    WITH Tot(Total) (
    SELECT COUNT(*) FROM table
    )
    SELECT Grade, COUNT(*) / Total * 100
--, CONVERT(VARCHAR, COUNT(*) /Total * 100) + '%'  -- With percentage sign
--, CONVERT(VARCHAR, ROUND(COUNT(*) /Total * 100, -2)) + '%'  -- With Round
    FROM table
    GROUP BY Grade
```
- Bien sûr, cela ne donne que les pourcentages pour les élèves de codes présents dans la table, pas pour ceux qui pourraient être présentes et ne le sont pas. Mais sans une liste définitive de la (valide) de grade codes, vous ne pouvez pas faire mieux. D'où le +1 de moi.
InformationsquelleAutor Jhonny D. Cano -Leftware-
9

Vous avez besoin de groupe sur la pente de terrain. Cette requête devrait vous donner ce que vous cherchez dans pratiquement n'importe quel base de données.
```
    Select Grade, CountofGrade / sum(CountofGrade) *100 
    from
    (
    Select Grade, Count(*) as CountofGrade
    From Grades
    Group By Grade) as sub
    Group by Grade
```
Vous devez spécifier le système que vous utilisez.
- Puisque vous avez un agrégat ('somme(CountofGrade)') dans la sélection externe, vous n'avez pas besoin d'une clause group by dans-il trop? Et dans le standard SQL, je pense que vous pouvez utiliser '/ (SELECT COUNT(*) à PARTIR de Notes) afin d'obtenir le total.
- IBM Informix Dynamic Server n'aime pas le nu SOMME dans la liste de sélection (bien qu'il donne un peu moins utiles message lorsqu'il se plaint). Comme indiqué dans ma réponse et observations antérieures, en utilisant une sous-expression de sélection dans la liste de sélection fonctionne dans ID.
- C'est aussi mieux car on peut appliquer complexe où à l'intérieur de la requête.
InformationsquelleAutor Jeremy
8

J'ai tout simplement à utiliser quand j'ai besoin de travailler sur un pourcentage..
```
ROUND(CAST((Numerator * 100.0 / Denominator) AS FLOAT), 2) AS Percentage
```
Remarque que 100,0 retourne décimales, alors que 100 sur son propre arrondir le résultat à l'entier le plus proche, même avec la fonction ROUND ()!

InformationsquelleAutor Fandango68
6

La suivante devrait fonctionner
```
ID - Key
Grade - A,B,C,D...
```
EDIT: Déplacé le * 100 et ajouté le 1.0 pour s'assurer qu'il ne fait pas de division entière
```
Select 
   Grade, Count(ID) * 100.0 / ((Select Count(ID) From MyTable) * 1.0)
From MyTable
Group By Grade
```
- cela fonctionne, mais toutes les réponses à revenir en 0 - ai-je besoin de faire une sorte de formatage de nombre ou à la conversion de voir la bonne réponse?
- Sélectionnez Grade, round(Count(grade) * 100.0 / ((Select Count(grade) à Partir de notes) * 1.0) ,2) des classes Du Groupe Par Grade pour l'ajout d'une fonction en sql-server returend par exemple : 21.56000000000
InformationsquelleAutor GordyII

C'est, je crois, une solution générale, bien que je l'ai testé à l'aide d'IBM Informix Dynamic Server 11.50.FC3. La requête suivante:

SELECT grade,
       ROUND(100.0 * grade_sum / (SELECT COUNT(*) FROM grades), 2) AS pct_of_grades
    FROM (SELECT grade, COUNT(*) AS grade_sum
            FROM grades
            GROUP BY grade
         )
    ORDER BY grade;

donne le résultat suivant sur les données de test ci-dessous la règle horizontale. Le ROUND fonction peut être spécifique de SGBD, mais le reste (probablement) ne l'est pas. (À noter que j'ai changé de 100 à 100,0 afin de s'assurer que le calcul se fait à l'aide non-entier DECIMAL, NUMERIC - arithmétique; voir les commentaires, et merci à Tonnerre.)

grade  pct_of_grades
CHAR(1) DECIMAL(32,2)
A       32.26
B       16.13
C       12.90
D       12.90
E       9.68
F       16.13

CREATE TABLE grades
(
id VARCHAR(10) NOT NULL,
grade CHAR(1) NOT NULL CHECK (grade MATCHES '[ABCDEF]')
);
INSERT INTO grades VALUES('1001', 'A');
INSERT INTO grades VALUES('1002', 'B');
INSERT INTO grades VALUES('1003', 'F');
INSERT INTO grades VALUES('1004', 'C');
INSERT INTO grades VALUES('1005', 'D');
INSERT INTO grades VALUES('1006', 'A');
INSERT INTO grades VALUES('1007', 'F');
INSERT INTO grades VALUES('1008', 'C');
INSERT INTO grades VALUES('1009', 'A');
INSERT INTO grades VALUES('1010', 'E');
INSERT INTO grades VALUES('1001', 'A');
INSERT INTO grades VALUES('1012', 'F');
INSERT INTO grades VALUES('1013', 'D');
INSERT INTO grades VALUES('1014', 'B');
INSERT INTO grades VALUES('1015', 'E');
INSERT INTO grades VALUES('1016', 'A');
INSERT INTO grades VALUES('1017', 'F');
INSERT INTO grades VALUES('1018', 'B');
INSERT INTO grades VALUES('1019', 'C');
INSERT INTO grades VALUES('1020', 'A');
INSERT INTO grades VALUES('1021', 'A');
INSERT INTO grades VALUES('1022', 'E');
INSERT INTO grades VALUES('1023', 'D');
INSERT INTO grades VALUES('1024', 'B');
INSERT INTO grades VALUES('1025', 'A');
INSERT INTO grades VALUES('1026', 'A');
INSERT INTO grades VALUES('1027', 'D');
INSERT INTO grades VALUES('1028', 'B');
INSERT INTO grades VALUES('1029', 'A');
INSERT INTO grades VALUES('1030', 'C');
INSERT INTO grades VALUES('1031', 'F');

donne entier pour cent en sql-server
intéressant; ce qui se produit si vous modifiez, disons, de l'ordre de 100 à 100.00?
Assurez-vous que le résultat est dans décimal avec 100.0

InformationsquelleAutor Jonathan Leffler

SELECT Grade, GradeCount / SUM(GradeCount)
FROM (SELECT Grade, COUNT(*) As GradeCount
FROM myTable
GROUP BY Grade) Grades

InformationsquelleAutor Aakashi

Dans toute version de sql server, vous pouvez utiliser une variable pour le total de toutes les classes comme ceci:

declare @countOfAll decimal(18, 4)
select @countOfAll = COUNT(*) from Grades
select
Grade,  COUNT(*) / @countOfAll * 100
from Grades
group by Grade

InformationsquelleAutor Steve Willcock

Vous pouvez utiliser une sous-sélection de votre à partir d'une requête (non testé, et pas sûr de ce qui est plus rapide):

SELECT Grade, COUNT(*) / TotalRows
FROM (SELECT Grade, COUNT(*) As TotalRows
FROM myTable) Grades
GROUP BY Grade, TotalRows

SELECT Grade, SUM(PartialCount)
FROM (SELECT Grade, 1/COUNT(*) AS PartialCount
FROM myTable) Grades
GROUP BY Grade

SELECT Grade, GradeCount / SUM(GradeCount)
FROM (SELECT Grade, COUNT(*) As GradeCount
FROM myTable
GROUP BY Grade) Grades

Vous pouvez également utiliser une procédure stockée (mes excuses pour la Firebird syntaxe):

SELECT COUNT(*)
FROM myTable
INTO :TotalCount;
FOR SELECT Grade, COUNT(*)
FROM myTable
GROUP BY Grade
INTO :Grade, :GradeCount
DO
BEGIN
Percent = :GradeCount / :TotalCount;
SUSPEND;
END

InformationsquelleAutor lc.

Vous devez vous connecter pour publier un commentaire.