L'association ActiveRecord sélectionne les enregistrements inclus

Exemple

class User  
  has_many :tickets 
end

Je veux créer une association qui contient la logique de compter les billets de l'utilisateur et de l'utilisation qu'il en comprend (utilisateur has_one ticket_count)

Users.includes(:tickets_count)

J'ai essayé

  has_one :tickets_count, :select => "COUNT(*) as tickets_count,tickets.user_id " ,:class_name => 'Ticket', :group => "tickets.user_id", :readonly => true  

User.includes(:tickets_count)

 ArgumentError: Unknown key: group

Dans ce cas, l'association de la requête à inclure doivent utiliser le comte avec le groupe ...
Comment puis-je mettre en œuvre cette aide de rails?

Mise à jour

  • Je ne peux pas changer de structure de table
  • Je veux AR générer 1 de la requête pour la collecte des utilisateurs avec comprend

Update2

Je sais SQL une je sais comment sélectionner ce avec des jointures, mais ma question est maintenant, comme "Comment obtenir des données" . Ma question est sur la construction de l'association que je peux utiliser en comprend. Grâce

Update3
J'ai essayé de créer une association créée comme utilisateur has_one ticket_count , mais

  1. ressemble has_one n'a pas d'association de soutien aux extensions
  2. has_one ne prend pas en charge :groupe option
  3. has_one ne prend pas en charge finder_sql

source d'informationauteur Fivell

  1. 12

    Essayez ceci:

    class User

  has_one :tickets_count, :class_name => 'Ticket', 
    :select => "user_id, tickets_count",
    :finder_sql =>   '
        SELECT b.user_id, COUNT(*) tickets_count
        FROM   tickets b
        WHERE  b.user_id = #{id}
        GROUP BY b.user_id
     '
end

    Edit:

    Il ressemble à la has_one association ne prend pas en charge la finder_sql option.

    Vous pouvez facilement obtenir ce que vous voulez en utilisant une combinaison de scope/class méthodes

    class User < ActiveRecord::Base

  def self.include_ticket_counts
    joins(
     %{
       LEFT OUTER JOIN (
         SELECT b.user_id, COUNT(*) tickets_count
         FROM   tickets b
         GROUP BY b.user_id
       ) a ON a.user_id = users.id
     }
    ).select("users.*, COALESCE(a.tickets_count, 0) AS tickets_count")
  end    
end

    Maintenant

    User.include_ticket_counts.where(:id => [1,2,3]).each do |user|
  p user.tickets_count 
end

    Cette solution a des implications sur les performances si vous avez des millions de lignes dans la tickets table. Vous devriez envisager de filtrage de les JOINDRE ensemble de résultats en fournissant WHERE à l'intérieur de la requête.

  2. 8

    Vous pouvez simplement utiliser pour un utilisateur particulier:

    user.tickets.count

    Ou si vous souhaitez que cette valeur automatiquement mises en cache par les Rails.

    Déclarer un counter_cache => true option dans l'autre côté de l'association

    class ticket
  belongs_to :user, :counter_cache => true
end

    Vous avez également besoin d'une colonne à vous utilisateur table nommée tickets_count.
    Avec cela à chaque fois que vous ajoutez un nouveau billet pour un utilisateur rails de mise à jour de cette colonne alors, quand vous ftech votre enregistrement d'utilisateur, vous pouvez simplement accs cette colonne pour obtenir le billet compter sans requête supplémentaire.

  3. 6

    Pas assez, mais il fonctionne:

    users = User.joins("LEFT JOIN tickets ON users.id = tickets.user_id").select("users.*, count(tickets.id) as ticket_count").group("users.id")
users.first.ticket_count
  4. 0

    Que sur l'ajout d'une méthode dans le modèle de l'Utilisateur qui effectue la requête?

    Vous ne seriez pas en modifiant la structure de la table, ou vous ne pouvez pas modifier ce soit?