仅从使用 sqlalchemy 在烧瓶应用程序中关注您的人那里获取帖子

Question

我有一个烧瓶应用程序，它混合使用了 sqlalchemy (ORM) 和烧瓶 sqlalchemy。

我有一个用户模型、一个帖子模型和一个关注者表，如下所示：

from app import db
from flask_login import UserMixin
from sqlalchemy.orm import relationship

class User(UserMixin, db.Model)
    id = db.Column(db.Integer, primary_key=True)
    followed = db.relationship('User', secondary=followers,
                               primaryjoin=(followers.c.follower_id == id),
                               secondaryjoin=(followers.c.followed_id == id),
                               backref=db.backref('followers', lazy='dynamic'), lazy='dynamic') # many to many relationship with other Users
    posts = relationship('Post') # one to many relationship with posts
    # ...

class Post(db.Model)
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    #...

followers= db.Table('followers',
                       db.Column('follower_id', db.Integer, db.ForeignKey('user.id')),
                       db.Column('followed_id', db.Integer, db.ForeignKey('user.id'))
                       )

我的问题是如何查询 Post 表/模型，以便它只返回关注您的用户（即朋友）撰写的帖子。
flask mega tutorial by Miguel Grinberg（这些模型的基础）使用以下 sqlalchemy 查询来完成与我所追求的类似的事情。

def followed_posts(self):
        return Post.query.join(
            followers, (followers.c.followed_id == Post.user_id)).filter(
                followers.c.follower_id == self.id).order_by(
                    Post.timestamp.desc())

我一直在尝试修改上述查询，以便 Post 表仅与关注者的子集连接，其特点是如果 (a,b) 在关注者中，然后是 (b,a) 在关注者中。我只是不确定如何实现这一点。

任何帮助将不胜感激。此外，如果有人推荐一个指南，可以在没有大量纯 SQL 先决条件知识的情况下进行更“高级”的 sqlalchemy 查询，例如上面的查询，请告诉我。 提前致谢！

Answer 1

为了在一个查询中执行并获得您想要的结果，以下两个选项应该产生相同的结果，但在pythonic 或SQL-ic 方面有很大不同。

选项 1： 我觉得这很 pythonic，因为 Poster.followed.any(...) 读作“其中一个追随者是 me。”。但是它产生的 SQL 有点“丑”，虽然它完成了工作：

    def followed_posts__elegant_any(self):
        user_id = self.id
        Poster = aliased(User, name="poster")
        return (
            object_session(self)
            .query(Post)
            .join(Poster, Post.user)
            .filter(Poster.followed.any(User.id == user_id))
            .filter(Poster.followers.any(User.id == user_id))
            .order_by(Post.timestamp.desc())
        )

选项 2：

这要简单得多，并且用非常“纯”的 SQL 逻辑表示：

• 创建别名以便可以在followers 表上加入两次
• 执行两次join，保证当前用户和“Poster”的关系是双向的。连接本身并没有真正用于其他任何事情，而是过滤：

def followed_posts__optimal_join(self):
    user_id = self.id
    f1 = aliased(followers)
    f2 = aliased(followers)
    return (
        object_session(self)
        .query(Post)
        .join(User, Post.user)
        .join(f1, and_(User.id == f1.c.follower_id, f1.c.followed_id == user_id))
        .join(f2, and_(User.id == f2.c.followed_id, f2.c.follower_id == user_id))
        .order_by(Post.timestamp.desc())
    )

Answer 2

我想通了。

def get_friend_posts():
    return Post.query.filter(Post.user_id.in_([f.id for f in self.followed if f.is_following(self)]))

# helper function
def is_following(self, user):
        return self.followed.filter(followers.c.followed_id == user.id).count() > 0