Question

言语中，我试图实现这一目标：

＆＃34;在comment.post_id == self.context.id中获取5条评论，并按最高评论数量_Vote.vote_type ==＆＃39;类似＆＃39;进行排序。＆＃34;

目前的模型是：

vote_enum = ENUM('like', 'dislike', name='vote_enum', create_type=False)

class User(Base):
    __tablename__='users'
    id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(65), nullable=False)
    comments = relationship('Comment', backref='user')
    comment_vote = relationship('Comment_Vote', backref='user')
    posts=relationship('Post', backref='user')

class Post(Base):
    __tablename__ = 'post'
    id = Column(Integer, primary_key=True, autoincrement=True)
    body= Column(String(1500))
    comments= relationship('Comment',backref='post', order_by='desc(Comment.date_created)', lazy='dynamic')
    owner_id= Column(Integer, ForeignKey('users.id'))

class Comment(Base):
    __tablename__='comment'
    id = Column(Integer, primary_key=True, autoincrement=True)
    body= Column(String(500))
    parent_id = Column(Integer, ForeignKey('comment.id'))
    post_id= Column(Integer, ForeignKey('post.id'))
    user_id= Column(Integer, ForeignKey('users.id'))
    children = relationship("Comment",
            backref=backref('parent', remote_side=[id]),
            lazy='dynamic'
            )
    del_flag= Column(Boolean, default=False)
    date_created= Column(DateTime(), default=datetime.datetime.utcnow())
    last_edited= Column(DateTime(), default=datetime.datetime.utcnow())
    comment_vote= relationship("Comment_Vote", backref="comment", lazy='dynamic')

class Comment_Vote(Base):
    __tablename__='comment_vote'
    id = Column(Integer, primary_key=True, autoincrement=True)
    user_id= Column(Integer, ForeignKey('users.id'))
    comment_id= Column(Integer, ForeignKey('comment.id'))
    vote_type = Column('vote_enum', vote_enum)

    @classmethod
    def total_likes(cls, comment_id, session):
        return session.query(cls).filter(cls.id == comment_id).first().comment_vote.filter(Comment_Vote.vote_type=='like').count()

我的功能查询是：

f = session.query(Comment_Vote.comment_id, funcfilter(func.count(1), Comment_Vote.vote_type == 'like').label('total_likes')).group_by(Comment_Vote.comment_id).subquery()

comments = session.query(Comment, f.c.total_likes).join(f, Comment.id==f.c.comment_id).filter(Comment.post_id == self.context.id).order_by('total_likes DESC').limit(5)

即使对于与该帖子无关的评论，这也会产生令人讨厌的副作用，即计算所有comment_vote＆＃39; like＆＃39;

我真的很感激有关如何重新排列这一点的一些建议，所以它不必先计算所有内容。我想要的可能是不可能的，而且我主要在ORM中工作。

SQLAlchemy背后的数据库是Postgresql。

Answer 1

这可能是使用lateral subquery的好地方。这是＆＃34; foreach＆＃34; SQL，也就是说，横向子查询可以引用前面FROM项的列。 Postgresql支持9.3版及更高版本的横向，SQLAlchemy from versions 1.1 and up：

from sqlalchemy import true

f = session.query(func.count(1).label('total_likes')).\
    filter(Comment_Vote.comment_id == Comment.id,  # References Comment
           Comment_Vote.vote_type == 'like').\
    subquery().\
    lateral()

comments = session.query(Comment, f.c.total_likes).\
    join(f, true()).\
    filter(Comment.post_id == self.context.id).\
    order_by(f.c.total_likes.desc()).\
    limit(5)

我将基于 vote_type 的过滤移动到子查询的WHERE子句，因为在这种情况下，首先获取所有行然后在聚合函数中过滤（也不能使用）是不必要的索引）。

当然在这种情况下你也可以在SELECT输出中使用scalar subquery来获得相同的效果：

f = session.query(func.count(1)).\
    filter(Comment_Vote.comment_id == Comment.id,  # References Comment
           Comment_Vote.vote_type == 'like').\
    label('total_likes')

comments = session.query(Comment, f).\
    filter(Comment.post_id == self.context.id).\
    order_by(f.desc()).\
    limit(5)

SQLAlchemy计算所有行，我想要特定的行

1 个答案: