Requête de filtre SQLAlchemy par objet connexe

Question

En utilisant SQLAlchemy, j'ai une relation de un à plusieurs avec deux tables - utilisateurs et scores. J'essaie d'interroger les 10 meilleurs utilisateurs triés par leur score global au cours des X derniers jours.

users: 
    id 
    user_name 
    score 

scores: 
    user 
    score_amount 
    created 

Ma requête en cours est:

top_users = DBSession.query(User).options(eagerload('scores')).filter_by(User.scores.created > somedate).order_by(func.sum(User.scores).desc()).all() 

Je sais que cela est clairement pas correct, il est juste ma meilleure estimation. Cependant, après avoir regardé la documentation et googling, je ne trouve pas de réponse.

EDIT: Peut-être que cela aiderait si je dessinai ce que la requête MySQL ressemblerait à ceci:

SELECT user.*, SUM(scores.amount) as score_increase 
FROM user LEFT JOIN scores ON scores.user_id = user.user_id 
WITH scores.created_at > someday 
ORDER BY score_increase DESC 

Answer 1

La voie rangée unique rejoint, avec une group_by ajoutée pour toutes les colonnes de l'utilisateur, bien que MySQL vous permettra de groupe uniquement sur la colonne « id » si vous choisissez:

sess.query(User, func.sum(Score.amount).label('score_increase')).\ 
       join(User.scores).\ 
       filter(Score.created_at > someday).\ 
       group_by(User).\ 
       order_by("score increase desc") 

Ou si vous voulez juste les utilisateurs du résultat:

sess.query(User).\ 
      join(User.scores).\ 
      filter(Score.created_at > someday).\ 
      group_by(User).\ 
      order_by(func.sum(Score.amount)) 

les deux ci-dessus ont une inefficacité que vous regroupement sur toutes les colonnes de chose « utilisateur » (ou que vous utilisez « groupe sur quelques colonnes » de MySQL, qui est MySQL seulement). Pour minimiser cela, l'approche sous-requête:

subq = sess.query(Score.user_id, func.sum(Score.amount).label('score_increase')).\ 
        filter(Score.created_at > someday).\ 
        group_by(Score.user_id).subquery() 
sess.query(User).join((subq, subq.c.user_id==User.user_id)).order_by(subq.c.score_increase) 

Un exemple du scénario identique est dans le tutoriel ORM à: http://docs.sqlalchemy.org/en/latest/orm/tutorial.html#selecting-entities-from-subqueries

Answer 2

Vous aurez besoin d'utiliser une sous-requête pour calculer le score global pour chaque utilisateur. Les sous-requêtes sont décrites ici:

Answer 3

Je suppose que la colonne (pas la relation) que vous utilisez pour la jointure s'appelle Score.user_id, donc changez-le si ce n'est pas le cas.

Vous aurez besoin de faire quelque chose comme ceci:

DBSession.query(Score.user_id, func.sum(Score.score_amount).label('total_score')).group_by(Score.user_id).filter(Score.created > somedate).order_by('total_score DESC')[:10] 

Cependant, cela se traduira par tuples de (user_id, total_score). Je ne sais pas si le score calculé est en fait important pour vous, mais si elle est, vous voudrez probablement faire quelque chose comme ceci:

users_scores = [] 
q = DBSession.query(Score.user_id, func.sum(Score.score_amount).label('total_score')).group_by(Score.user_id).filter(Score.created > somedate).order_by('total_score DESC')[:10] 
for user_id, total_score in q: 
    user = DBSession.query(User) 
    users_scores.append((user, total_score)) 

Cela se traduira par 11 requêtes en cours d'exécution, cependant. Il est possible de tout faire en une seule requête, mais en raison de diverses limitations dans SQLAlchemy, il va probablement créer une requête ou sous-requête à plusieurs jointures très moche (en fonction du moteur) et elle ne sera pas très performante.

Si vous prévoyez de faire quelque chose comme ça souvent et que vous avez une grande quantité de scores, pensez à dénormaliser le score actuel sur la table des utilisateurs. Il est plus de travail à l 'entretien, mais se traduira par une seule requête non comme se joindre à:

DBSession.query(User).order_by(User.computed_score.desc()) 

espoir qui aide.