【问题标题】:How to filter exact many to many如何过滤精确的多对多
【发布时间】:2017-03-10 19:37:10
【问题描述】:

我在 Flask SQLAlchemy 中有用户和房间模型。我需要过滤 Room 是否与用户 [user1, user2, ...] 一起存在。过滤器必须准确。
这是我的模型:

room_users_table = db.Table(
  'room_users',
    db.metadata,
    db.Column('user', db.Integer, db.ForeignKey('user.id')),
    db.Column('room', db.Integer, db.ForeignKey('room.id'))
)

class User(db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True)
    first_name = db.Column(db.String(80))
    last_name = db.Column(db.String(80))
    password = db.Column(db.String(80))
    email = db.Column(db.String(120), unique=True)
    rooms = db.relationship(
        "Room",
        secondary=room_users_table,
        back_populates="users"
    )

class Room(db.Model):
   __tablename__ = 'room'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), unique=True)
    users = db.relationship(
        "User",
        secondary=room_users_table,
        back_populates="rooms"
    )

谢谢,我已经搜索了所有类似的问题,但找不到答案。

【问题讨论】:

  • 确切的意思是Room 必须只有Users 和给定的电子邮件作为房间用户?没有给定电子邮件的房间,可能还有其他一些。
  • 是的,你没看错。只有给定用户的房间。例如,如果我想发送消息 2 User1 和 User2,我需要知道我们 3 的房间是否已经存在。而且我只需要我们 3 的房间,而不是我们 3 和其他一些用户的房间。我希望,示例对您有所帮助。

标签: python sqlalchemy flask-sqlalchemy


【解决方案1】:

您可以使用relational division 的版本和一些额外的过滤来实现此目的:

首先为您要搜索的电子邮件构建一个临时“表”(联合):

In [46]: emails = ['email1@mail.com', 'email2@mail.com']

In [47]: emails_union = db.union(*(db.select([db.literal(email).label('email')])
                                   for email in emails)).alias()

这可能看起来有点不受欢迎,但它本质上形成了一个 SQL UNION,如下所示:

SELECT 'email1@mail.com' AS email
UNION
SELECT 'email2@mail.com' AS email

并给它一个别名。一些数据库可能支持其他方式从列表中生成新关系,for example with Postgresql you could:

In [64]: from sqlalchemy.dialects.postgresql import array

In [65]: emails_relation = db.func.unnest(array(emails)).alias()

除法本身是使用双重否定或 2 个嵌套的 NOT EXISTS 条件完成的:

In [48]: db.session.query(Room).\
    ...:     filter(~db.session.query().select_from(emails_union).
    ...:                filter(~Room.users.any(email=emails_union.c.email)).
    ...:                exists(),
    ...:            ~Room.users.any(User.email.notin_(emails))).\
    ...:     all()
Out[48]: [<__main__.Room at 0x7fad4d238128>]

In [49]: [(r.name, [u.email for u in r.users]) for r in _]
Out[49]: [('room1', ['email1@mail.com', 'email2@mail.com'])]

该查询几乎回答了“找到那些不存在Room.users 中不存在此类电子邮件的Rooms”这个问题——它会找到包含所有给定电子邮件的房间——然后它应用第三个不存在条件,它会过滤掉带有其他电子邮件的房间。没有它,查询也将返回 room2,其中包含电子邮件 1、2 和 3。

搜索是针对这些数据进行的:

In [10]: users = [User(id=id_, email='email{}@mail.com'.format(id_))
    ...:          for id_ in range(1, 10)]

In [11]: rooms = [Room(id=id_, name='room{}'.format(id_))
    ...:          for id_ in range(1, 10)]

In [18]: db.session.add_all(users)

In [19]: db.session.add_all(rooms)

In [20]: for room, user1, user2 in zip(rooms, users, users[1:]):
    ...:     room.users.append(user1)
    ...:     room.users.append(user2)
    ...:     

In [21]: rooms[1].users.append(users[0])

In [22]: db.session.commit()

【讨论】:

    【解决方案2】:

    经过两天的研究,我有了一个临时解决方案。

    -- room_users is the "secondary" table in 
       -- sqlalchemy many to many between User and Room
    select room.name, room_users.room 
        from room_users join room on room_users.room = room.id 
        where room_users.user in (1,2) 
        group by room_users.room having count(*) = 2;
    

    在 python 中它会是这样的:

    # members contains user emails
    members = ['email1@mail.com', 'email2@mail.com']
    db.session.query(Room.name).join(Room.users).filter(
        User.email.in_(members)
    ).group_by(Room.id).having(
        func.count(Room.id) == len(members)
    ).first()
    

    【讨论】:

    • 查询最终也会返回不精确匹配的房间,因为 JOIN 只会产生匹配 IN 条件的行——过滤掉可能的额外用户——因此所有拥有给定用户的房间电子邮件将在组中生成len(members) 行。例如,如果您的房间包含用户 email1、2 和 3,则此查询将返回它。
    • 你是对的,它不起作用。但不是在你的例子中,因为计数将是 2。但是当我过滤三个用户,并找到有 2 个用户作为成员的房间并且最后一个成员将是另一个用户时,这个房间将在结果中,因为计数将是3. 我不明白为什么这么复杂。我需要重新考虑应用程序架构。谢谢@IljaEverilä
    • 不确定“计数将是 3”是什么意思。对于所有拥有电子邮件 email1@mail.com 和 email2@mail.com 的用户的房间,它将为 2,因为在 JOIN 和 WHERE 子句过滤之后留下了这些行每个房间组。
    • 哦,真的,现在我明白了。
    猜你喜欢
    • 1970-01-01
    • 2012-11-15
    • 1970-01-01
    • 2020-12-11
    • 2014-07-17
    • 2020-01-11
    • 1970-01-01
    • 2016-06-18
    • 2016-10-11
    相关资源
    最近更新 更多