SQLAlchemy: में सदस्यता द्वारा फिल्टर कम से कम एक कई करने के लिए कई संबंधित तालिका

Question

SQLAlchemy 0.7.1 और एक MySQL 5.1 डेटाबेस का उपयोग करना, मुझे मिल गया है एक कई-से-अनेक संबंध के रूप में स्थापित इस प्रकार है:

user_groups = Table('user_groups', Base.metadata, 
    Column('user_id', String(128), ForeignKey('users.username')), 
    Column('group_id', Integer, ForeignKey('groups.id')) 
) 

class ZKUser(Base, ZKTableAudit): 
    __tablename__ = 'users' 

    username = Column(String(128), primary_key=True) 
    first_name = Column(String(512)) 
    last_name = Column(String(512)) 

    groups = relationship(ZKGroup, secondary=user_groups, backref='users') 

class ZKGroup(Base, ZKTableAudit): 
    __tablename__ = 'groups' 

    id   = Column(Integer, primary_key=True) 
    name  = Column(String(512)) 

उपयोगकर्ता कई समूह से संबंधित हो सकते हैं, और समूह में एकाधिक उपयोगकर्ता हो सकते हैं।

जो मैं करने की कोशिश कर रहा हूं वह एक स्क्लेक्लेमी क्वेरी बनाता है जो केवल उन उपयोगकर्ताओं को लौटाता है जो समूह की सूची में से कम से कम एक समूह से संबंधित हैं।

मैंने in_ फ़ंक्शन के साथ खेला, लेकिन यह केवल सूची में सदस्यता के लिए स्केलर मानों का परीक्षण करने के लिए काम करता है। मैं एक एसक्यूएल लेखक का अधिक नहीं हूं, इसलिए मुझे यह भी पता नहीं है कि SELECT कथन किस प्रकार की आवश्यकता होगी।

Answer 1

ठीक है, अनुसंधान के एक बहुत बाद, मुझे एहसास हुआ कि यह एसक्यूएल शब्दावली है कि मुझे पकड़े हुए था वापस की अपने ही अज्ञान था। समूहों की सूची में से "कम से कम" से संबंधित उपयोगकर्ताओं को ढूंढने के समाधान के लिए मेरी खोज को समूहों की सूची के "किसी भी" से संबंधित उपयोगकर्ताओं को ढूंढना चाहिए था।

session.query(ZKUser).filter(ZKUser.groups.any(ZKGroup.id.in_([1,2,3]))) 

कि कोड इस एसक्यूएल (MySQL 5.1 पर) का उत्सर्जन करता है:

SELECT * FROM users 
WHERE EXISTS (
    SELECT 1 FROM user_groups, groups 
    WHERE users.id = user_groups.contact_id 
     AND groups.id = user_groups.group_id 
     AND groups.id IN (%s, %s, %s) 
    ) 

Answer 2

आप in_ उपयोग कर सकते हैं:

session.query(ZKUser).filter(ZKGroup.id.in_([1,2])).all() 

Answer 3

the docs for any के अनुसार, क्वेरी तेजी से करता है, तो चलेंगे SQLAlchemy से any ORM समारोह मैं, वास्तव में क्या जरूरत है तो तरह करता है आप एक स्पष्ट join बजाय का उपयोग करें:

क्योंकि किसी भी() एक सहसंबद्ध सबक्वेरी का उपयोग करता है, इसके प्रदर्शन को लगभग रूप में अच्छा है जब के रूप में बड़े लक्ष्य तालिकाओं के खिलाफ तुलना नहीं की है शामिल होने का उपयोग करना।

आपके मामले में, आप कुछ कर सकते हैं की तरह:

users = (
    session.query(ZKUser) 
    .join(user_groups) 
    .filter(user_groups.columns.group_id.in_([1, 2, 3])) 
) 

यह उत्सर्जन करता है एसक्यूएल की तरह: जब मैं के बाद कार्यालय के लिए वापस पाने के

SELECT * 
FROM users 
JOIN user_groups ON users.id = user_groups.user_id 
WHERE user_groups.group_id IN (1, 2, 3)