Rails 3: .group () commandés par created_at

Qu'est-ce que les Rails à 3 voies à l'ordre .groupe() des résultats de Activerecord (ici par "created_at")?

@messages = Message.group(:foo)

seulement les résultats en affichant le message le plus ancien. J'avais besoin de la dernière à être montré.

J'ai essayé

@messages = Message.group(:foo).having("created_at = MAX(created_at)")

sans succès. Tous les conseils apprécié!

Pour clarifier: je cherche à avoir le groupe a ordonné à l'intérieur de lui-même, pas les messages normaux.commande("...").
Devrait-il pas être facile de Activerecord la syntaxe, je serais heureux avec SQL brut ainsi

Mise à jour: essayer le SQL façon, c'est censé fonctionner:

@messages = Message.find_by_sql("
  SELECT messages.* 
  FROM messages 
  GROUP BY messages.foo 
  HAVING messages.created_at = MAX(messages.created_at) 
  ORDER BY messages.created_at DESC")

Mais cela permet de récupérer uniquement les enregistrements unique (ceux qui ne sont pas groupés). Soi-disant groupés sont omis. Ne sais pas pourquoi, tous les dossiers :created_at et :foo valeurs

source d'informationauteur David

6

Vous ne pouvez pas utiliser la commande puis de les regrouper dans la même requête, en vertu de certaines bases de données, alors vous devez vous faire à l'aide de deux requêtes:
```
message_ids = Message.select("MAX(id) AS id").group(:foo).collect(&:id)
@messages = Message.order("created_at DESC").where(:id => message_ids)
```
Note: ceci suppose que vous avez un auto-incrémenté id colonne, dont la plupart des Rails de tableaux.
2

Vous pouvez aller SQL, mais vous pouvez aussi surtout rester dans activerecord terre avec
```
@messages = Message.select('DISTINCT ON (foo) *').order(:created_at).reverse_order
```
La DISTINCT ON () syntaxe est postgres. Il y a un semblable, mais une syntaxe légèrement différente dans MYSQL.

Je pense que cette requête va finir par être beaucoup plus efficace, aussi, que l'on a accepté la réponse, car il suffit d'un seul de tri et d'analyse, à la place de N sortes.
1

A tout de travail à l'aide d'un plus dédié à la sous-requête, sans un GROUPE PAR appel:
```
SELECT *
   FROM `messages`
   WHERE `id` = (
      SELECT `id`
      FROM `messages` as `alt`
      WHERE `alt`.`foo` = `messages`.`foo`
      ORDER BY `created_at` DESC
      LIMIT 1
   )
   ORDER BY `created_at` DESC
```
Tous grâce au Chaos de réponse dans ce fil: Sélectionner les 3 documents les plus récents, où les valeurs d'une colonne sont distincts

Ne sais pas à propos des implications en termes de vitesse et pourtant, bien que. Si quelqu'un veut intervenir, n'hésitez pas à le faire.
1

Je viens de tomber sur ce même problème. La suite de Rails requête a fonctionné pour moi:
```
Message.where("id IN (SELECT MAX(id) FROM messages GROUP BY id) AND state = 'unread'")
```
Ici, nous utilisons une sous-requête pour obtenir la plus grande (et donc la plus récente) ID dans chaque groupe, puis les filtre pour afficher uniquement celles où l'état == 'non lu'.

Astuce: j'ai fait une auto.dernière méthode dans mon Message modèle de classe qui se composait de:
```
def self.latest
  where("id IN (SELECT MAX(id) FROM messages GROUP BY id)
end
```
Ce qui signifiait que je pouvais l'utiliser dans les contrôleurs comme ceci:
```
Message.latest.where(state: 'unread')
```
0

Je ne vois pas comment cela pourrait être fait en utilisant Arel facilement - mais si vous allez construire votre propre SQL comme vous l'avez fait dans votre question, puis de le modifier comme suit:
```
@messages = Message.find_by_sql("
  SELECT messages.* 
  FROM messages 
  GROUP BY messages.foo 
  HAVING messages.created_at = (SELECT max(created_at) FROM messages AS sub_messages WHERE sub_messages.foo = messages.foo)
```
Note de la sous-requête dans la clause HAVING. Votre clause HAVING a calculé le MAX sur l'ensemble de vos messages, et pas seulement pour les messages à l'intérieur foo. La sous-requête devrait résoudre le problème.

Je l'alias de la table des messages nom de sub_messages - mais qui ne devrait pas être nécessaire. Je l'ai juste fait pour "montrer" comment les parents et les sous-requête travailler ensemble.

Vous devez vous connecter pour publier un commentaire.