Somme sur plusieurs colonnes avec Activerecord

Je suis nouveau à Activerecord. Je veux faire la somme sur plusieurs colonnes d'un Étudiant modèle. Mon élève modèle est comme suit:

 class Student < ActiveRecord::Base
   attr_accessible :class, :roll_num, :total_mark, :marks_obtained, :section
 end

Je veux quelque chose comme ça:

 total_marks, total_marks_obtained = Student.where(:id=>student_id).sum(:total_mark, :marks_obtained)

Mais il est donné suite à l'erreur.

NoMethodError: undefined method `except' for :marks_obtained:Symbol

Donc je me demande si je dois interroger le modèle à deux reprises pour le haut, c'est à dire à trouver le total des marques et de l'autre, pour trouver les résultats obtenus.

pouvez-vous montrer à votre modèle , et que la colonne de votre table ?
Quelle erreur avez-vous?
Je suis NoMethodError: undefined method `sauf' pour :total_marks_obtained:Symbole

OriginalL'auteur Joy | 2014-02-20

activerecord ruby-on-rails

14

Vous pouvez utiliser SQL brut si vous en avez besoin. Quelque chose comme cela pour retourner un objet où vous devrez extraire les valeurs... je sais que vous spécifiez active record!
```
Student.select("SUM(students.total_mark) AS total_mark, SUM(students.marks_obtained) AS marks obtained").where(:id=>student_id)
```
Pour les rails 4.2 (précédemment désélectionné)
```
Student.select("SUM(students.total_mark) AS total_mark, SUM(students.marks_obtained) AS marks obtained").where(:id=>student_id)[0]
```
NB les crochets à la suite de la déclaration. Sans elle, l'instruction retourne une Classe::ActiveRecord_Relation, pas l'instance AR. Ce qui est important, c'est que vous NE pouvez pas utiliser first sur la relation.
```
....where(:id=>student_id).first #=> PG::GroupingError: ERROR:  column "students.id" must appear in the GROUP BY clause or be used in an aggregate function
```
convient de noter ici qu'un alias de nom de colonne doit correspondre à l'un des noms réels des colonnes de la table
.first est de travailler avec moi sur 4.2.5
Malheureusement, cela ne semble pas fonctionner sur toutes les occasions, par exemple en essayant de sélectionner sur l'association ou sur une table jointe avec includes(). J'ai trouvé que vous pouvez réellement d'approvisionnement aggragate fonctions dans pluck(), par exemple, Student.pluck("sum(total_mark)", "sum(marks_obtained)") que la réponse ici: stackoverflow.com/a/41606066/2067695

OriginalL'auteur penner
10

Vous pouvez utiliser plumer pour obtenir directement la somme:
```
Student.where(id: student_id).pluck('SUM(total_mark)', 'SUM(marks_obtained)')
# SELECT SUM(total_mark), SUM(marks_obtained) FROM students WHERE id = ?
```
Vous pouvez ajouter des colonnes ou des champs calculés à pluck méthode, et il va retourner un tableau avec les valeurs.

Tiens juste à ajouter que cette retournera un tableau imbriqué à l'intérieur d'un autre tableau (dans les Rails 4.2, au moins), donc n'oubliez pas d'appeler flatten sur le résultat.
Cela semble être tranquillement la conversion de flotteurs en nombres entiers pour moi.

OriginalL'auteur AlexGuti
8

Si vous voulez juste somme des colonnes total_marks et marks_obtained, essayez cette
```
Student.where(:id=>student_id).sum('total_mark + marks_obtained')
```
OriginalL'auteur YasirAzgar
3

Une autre méthode consiste à ActiveRecord::Calculs.plumer puis Énumérable#somme à l'extérieur sur le tableau et de nouveau à l'intérieur de la matrice de paire:
```
Student
  .where(id: student_id)
  .pluck(:total_mark, :marks_obtained)
  .map(&:sum)
  .sum
```
L'résultant de la requête SQL est simple:
```
SELECT "students"."total_mark",
       "students"."marks_obtained"
FROM "students"
WHERE "students"."id" = $1
```
Le résultat initial de pluck sera un tableau de tableau de paires, par exemple:
```
[[10, 5], [9, 2]]
```
.map(&:sum) sera exécuté sum sur chaque paire, le total de la paire et de l'aplatissement de la matrice:
```
[15, 11]
```
Enfin .sum sur le aplatie tableau résultera en une valeur unique.

Edit:

Noter que, si il y a une seule requête, votre base de données retourne une ligne de résultat pour chaque enregistrement correspondant dans la where. Cette méthode utilise ruby pour faire le total, donc, si il ya de nombreux enregistrements (c'est à dire des milliers), ce peut être plus lent que d'avoir SQL pour faire les calculs lui-même comme noté dans l'acceptation de réponse.

Vous pouvez utiliser pluck d'obtenir directement la somme: Student.where(id: student_id).pluck('SUM(total_mark)', 'SUM(marks_obtained)')
Veuillez présenter que comme une réponse, pas juste un commentaire!

OriginalL'auteur Marc Greenstock
1

Similaire à la accepté de répondre, cependant, je te suggère d'utiliser arel comme suit pour éviter les littéraux de chaîne (à l'exception de renommer les colonnes, si nécessaire).
```
Student
  .where(id: student_id).
  .where(Student.arel_table[:total_mark].sum, Student.arel_table[:marks_obtained].sum)
```
qui va vous donner un ActiveRecord::Relation résultat sur lequel vous pouvez effectuer une itération, ou, comme vous n'obtiendrez qu'une seule ligne, vous pouvez utiliser .first (au moins pour mysql).

OriginalL'auteur willyab

Vous devez vous connecter pour publier un commentaire.