如何篩選確切的多對多

Question

我在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" 
    ) 

謝謝，我已經找遍了所有simular問題，並不能找到答案。

Answer 1

經過兩天的研究，我有一個臨時解決方案。

-- 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; 

在蟒蛇會是這樣的：

# 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() 

Answer 2

可以使用一個版本的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」，該電子郵件不存在於Room.users「 - 它找到了具有所有給定電子郵件的房間 - 然後它應用第三個NOT EXISTS條件，該條件過濾掉帶有額外電子郵件的房間。沒有它，查詢也將返回房間2，裏面有郵件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()