मैं एसक्लाक्लेमी (ओआरएम) में 3 टेबलों पर कई से अधिक रिश्तों को कैसे मॉडल करूं?

Question

मैं एसक्यूएल में जंगली हूं और SQL Alchemy पर पूरी तरह से नया हूं, लेकिन एक आगामी प्रोजेक्ट है जो दोनों का उपयोग करता है। तो मैंने सोचा कि मैं आराम से कुछ लिखता हूं। एक हैंगओवर से पीड़ित मैंने अल्कोहल के स्तर को ट्रैक रखने के लिए कुछ लिखने का फैसला किया।

मैं events जहां users भाग लेने और उपभोग drinks है। वे मेरी तीन मूल सारणी हैं (एक सहायक तालिका guestlist के साथ, उपयोगकर्ताओं और ईवेंट के बीच एम: एन संबंध के लिए।

पेय सूची पेय सभी घटनाओं सभी उपयोगकर्ताओं के हर समय (कुछ भी मैप करने के लिए कोई जरूरत नहीं) पर उपलब्ध है। उपयोगकर्ता समय-समय पर बनाए जाते हैं, इसलिए ईवेंट हैं। सभी उपयोगकर्ता सभी ईवेंट में शामिल हो सकते हैं, इसलिए मैं उन मानचित्रों को मानचित्रित करने के लिए guestlist तालिका का उपयोग करता हूं।

अब प्रश्न के दिल में: मुझे ट्रैक रखने की आवश्यकता है कि किस समय उपयोगकर्ता उपभोग करता है जो किस घटना पर पीता है। मैं इस श्वेत को अन्य तालिका shots (नीचे देखें) को हल करने का प्रयास करता हूं लेकिन मुझे यकीन नहीं है कि यह एक अच्छा समाधान है या नहीं।

ERP Diagram http://s1.anyimg.com/img/g6ld1ku/Bildschirmfoto.png

SQL Alchemy में यह इस तरह कुछ हद तक लग सकता है (या नहीं, लेकिन यह है कि क्या मैं अब तक के साथ आया था) ::

guestlist_table = Table('guestlist', Base.metadata, 
    Column('event_id', Integer, ForeignKey('events.id')), 
    Column('user_id', Integer, ForeignKey('users.id')) 
) 

class Event(Base): 

    __tablename__ = 'events' 

    id = Column(Integer, primary_key=True) 
    name = Column(String(80), nullable=False) 
    started = Column(DateTime, nullable=False, index=True, 
    default=datetime.datetime.now 
) 
    users = relationship("User", secondary=guestlist_table, backref="events") 
    # ... 

class User(Base): 

    __tablename__ = 'users' 

    id = Column(Integer, primary_key=True) 
    name = Column(String(50), nullable=False, unique=True, index=True) 
    birthdate = Column(Date, nullable=False) 
    weight = Column(Integer, nullable=False) 
    sex = Column(Boolean, nullable=False) 
    # ... 

class Drink(Base): 

    __tablename__ = 'drinks' 

    id = Column(Integer, primary_key=True) 
    name = Column(String(50), nullable=False) 
    volume = Column(Numeric(5,2), nullable=False) 
    percent = Column(Numeric(5,2), nullable=False) 
    # ... 

class Shots(Base): 

    __tablename__ = 'shots' 

    id = Column(Integer, primary_key=True) 
    at = Column(DateTime, nullable=False, 
    default=datetime.datetime.now 
) 
    user_id = Column(Integer, ForeignKey('users.id'), index=True) 
    event_id = Column(Integer, ForeignKey('events.id'), index=True) 
    drink_id = Column(Integer, ForeignKey('drinks.id')) 
    user = relationship("User", backref="shots") 
    event = relationship("Event", backref="shots") 
    drink = relationship("Drink", uselist=False) # one-to-one, no backref needed 

मैं निर्माण करने के लिए एक अच्छा रास्ता खोजने के लिए संघर्ष एक तालिका घटनाओं, उपयोगकर्ताओं और पेय एक साथ नक्शे: मैं कैसे relationships तैयार करना चाहिए और कैसे मैंकरनायह?

बात यह है कि मुझे लगता है कि मैंने कुछ अनदेखा किया है। और स्पष्ट रूप से मैं क्वेरी पर कैसे खो गया हूं?

• मैं कम से कम सभी दृश्यों एक घटना पर भस्म प्राप्त करने की आवश्यकता (शायद उपयोगकर्ता के अनुसार क्रमबद्ध)
• मैं भी कभी कभी सभी दृश्यों की जरूरत है:

  यहाँ प्रश्नों मैं समय के सबसे बनाना होगा रहे हैं

  • घटना प्रति शॉट्स की संख्या
  • यू प्रति शॉट्स की संख्या: एक विशिष्ट उपयोगकर्ता (शायद घटना के अनुसार क्रमबद्ध)
  • और गिनती चालू की एक बहुत कुछ के लिए सेवा
  • शॉट्स की संख्या एक उपयोगकर्ता एक घटना

पर गिरे हुए shots तालिका इस प्रबंधन के लिए एक ठीक तरीका है?

Answer 1

मेरा सुझाव है कि आप एक एंटिटी रिलेशनशिप आरेख तैयार करें, यह लोगों के लिए और अधिक स्पष्ट होगा कि आप अपने प्रश्न को समझ सकें।

आपके प्रश्न का उत्तर करने के लिए:

मैं कम से कम सभी दृश्यों एक घटना (शायद उपयोगकर्ता के अनुसार क्रमबद्ध)

एक घटना के सभी शॉट्स पाने के लिए आपको सकता है पर भस्म प्राप्त करने की आवश्यकता

session.query(Shots).filter_by(event_id=event_id) 

event_id उस ईवेंट की आईडी है जिसे आप क्वेरी करना चाहते हैं। उपयोगकर्ता द्वारा की दुकान के लिए, आपको

from sqlalchemy.sql.expression import desc, asc 
session.query(Shots) \ 
    .filter_by(event_id=event_id) \ 
    .order_by(asc(Shots.user_id)) 

बेशक

कोशिश कर सकते हैं, तो आप एक उपयोगकर्ता की विशेषता के आधार पर सॉर्ट करने के लिए, आप उपयोगकर्ता तालिका शामिल हो सकते हैं कर सकते हैं।

from sqlalchemy.sql.expression import desc, asc 
session.query(Shots) \ 
    .filter_by(event_id=event_id) \ 
    .join(User) \ 
    .order_by(asc(User.name)) 

काफी आसान है।

मैं भी कभी कभी एक विशिष्ट उपयोगकर्ता (शायद घटना के अनुसार क्रमबद्ध)

बस पिछले उदाहरण की तरह के लिए सभी दृश्यों की जरूरत

घटना

session.query(Shots) \ 
    .filter_by(event_id=event_id) \ 
    .count() 

प्रति शॉट्स की संख्या

मैंने उन्हें नहीं चलाया, मैंने अभी उन्हें यहां लिखा है, लेकिन वे यदि मैंने टाइपो नहीं बनाया तो सभी काम करना चाहिए।