एक साधारण शिक्षक-विषय-छात्र-बैच संबंधपरक डेटाबेस को डिजाइन करने का तरीका क्या है?

आप विषयों और छात्रों को जोड़ने वाली एक तालिका याद कर रहे हैं (प्रति बिंदु 2):

// student [student_id] takes subject [subject_id]
takes(student_id, subject_id)

ध्यान दें कि प्रत्येक आधार तालिका में व्यावसायिक स्थिति के बारे में बयानों के लिए एक संबद्ध स्टेटमेंट टेम्प्लेट होता है, जो कॉलम नामों द्वारा पैरामीटर किया जाता है--इसकी (विशेषता) विधेय . विधेय को सत्य बनाने वाली पंक्तियाँ तालिका में जाती हैं। ध्यान दें कि तालिका परिभाषा विधेय के लिए आशुलिपि की तरह दिखती है।

// teacher [id] named [name] with email [email] teaches subject [subject_id]
teacher(id, name, email, subject_id)

// subject [id] named [name] is [description]
subject(id, name, description)

// student [id] named [name] lives at [location])
student(id, name, location)

// batch [id] at venue [venue] was taught by teacher [teacher_id] on date [date]
batch(id, venue, teacher_id, date)

// student-batch [id] reports student [student_id] being in batch [batch_id]
student-batch(id, student_id, batch_id)
// CHECK student [student_id] takes the subject that is taught by the teacher of batch [batch_id]

चूंकि आप इसके बारे में स्टम्प्ड लगते हैं, इसलिए मैं इसे इस संदर्भ में प्राप्त करूंगा कि हम टेबल, बाधा और क्वेरी डिज़ाइन के लिए कैसे तर्क कर सकते हैं। आप जो बाधा चाहते हैं उसे व्यक्त करने का एक तरीका ऊपर टिप्पणी की गई जांच है।

SQL में किसी भी तालिका, बाधा या क्वेरी को व्यक्त करने के लिए हम पहले उसके विधेय पर निर्णय लेते हैं। तब हम विधेय को आशुलिपि में बदल सकते हैं। तब हम शॉर्टहैंड को SQL में बदल सकते हैं।

विधेय:

student [student_id] takes the subject that is taught by the teacher of batch [batch_id]

बेस टेबल विधेय का उपयोग करना:

FOR SOME k.*, t.*, b.* (
    student_id = k.student_id AND batch_id = b.bid
AND student [k.student_id] takes subject [k.subject_id]
AND teacher [t.id] named [t.name] with email [t.email] teaches subject [t.subject_id] 
AND batch [b.id] at venue [b.venue] was taught by teacher [b.teacher_id] on date [b.date]
AND [k.subject_id] = [t.subject_id]
AND [t.id] = [b.teacher_id])

शॉर्टहैंड का उपयोग करना:

FOR SOME k.*, t.*, b.* (
    student_id = k.student_id AND batch_id = b.bid
AND takes(k.student_id, k.subject_id)
AND teacher(t.id, t.name, t.email, t.subject_id)
AND batch(b.id, b.venue, b.teacher_id, date)
AND k.subject_id = t.subject_id
AND t.id = b.teacher_id)

FROM में से प्रत्येक (संभवतः निहित) उपनाम दिए गए बेस टेबल नाम और/या सबक्वेरी जैसी तालिका का प्रतिनिधित्व करता है, लेकिन इसके मूल्य और विधेय में प्रत्येक कॉलम के साथ उपनाम का नाम बदल दिया जाता है .कॉलम ।

हमें SQL में विधेय की तालिकाओं में शामिल होने से AND दो विधेय को संतुष्ट करने वाली पंक्तियाँ प्राप्त होती हैं। यदि हम चाहते हैं कि पंक्तियाँ किसी शर्त के AND को संतुष्ट करें तो हम SQL में ON या WHERE का उपयोग करते हैं।

एक सेलेक्ट क्लॉज उन पंक्तियों को लौटाता है जहां बिंदीदार कॉलम के कुछ मूल्यों के लिए लौटाए गए (अनडॉटेड) कॉलम डॉटेड कॉलम के कार्यों के बराबर होते हैं जो FROM विधेय को संतुष्ट करते हैं।

SQL:स्टेटमेंट्स को उनकी टेबल से बदलें, और JOIN या ON या WHERE द्वारा, और कुछ के लिए बाहरी और वहाँ सेलेक्ट करें:

SELECT t.student_id AS student_id, b.bid AS batch_id
FROM takes k JOIN teacher t JOIN batch b
WHERE k.subject_id = t.subject_id
AND t.id = b.teacher_id
AND student_id = t.student_id
AND batch_id = b.id

दो विधेय के OR को संतुष्ट करने वाली पंक्तियों की तालिका उनकी तालिकाओं का UNION है। के लिए और नहीं हम EXCEPT (उर्फ माइनस) (या एक बाएं जॉइन मुहावरे) का उपयोग करते हैं। SQL में सभी स्तंभों पर कुछ या वहाँ मौजूद हैं, को क्वेरी नहीं किया जा सकता है, लेकिन अगर हम जानना चाहते हैं कि क्या एक विधेय को संतुष्ट करने वाली पंक्तियाँ हैं तो हम उस विधेय के साथ एक सबक्वेरी के आसपास EXISTS का उपयोग कर सकते हैं।

मान लीजिए कि हम एक आधार तालिका को बाधित करना चाहते हैं ताकि प्रत्येक पंक्ति कुछ स्तंभों पर एक विधेय को संतुष्ट करे। यानी सभी स्तंभों के लिए यदि वे आधार विधेय को संतुष्ट करते हैं तो वे क्वेरी विधेय को संतुष्ट करते हैं। यानी सभी स्तंभों के लिए यदि वे जो पंक्ति बनाते हैं वह आधार में है तो यह क्वेरी में है। तो हमें एसक्यूएल में आवश्यकता है जो मौजूद नहीं है (क्वेरी को छोड़कर आधार से कॉलम चुनें)। या बेस में प्रत्येक पंक्ति के लिए हमें SQL में EXISTS (क्वेरी) की आवश्यकता होती है।

मानक SQL में आप ASSERTION CHECK बना सकते हैं (EXISTS नहीं (छात्र-बैच से बैच_आईडी चुनें, क्वेरी को छोड़कर)) या एक क्रिएट टेबल छात्र-बैच में आप जांच कर सकते हैं (EXISTS (क्वेरी))। दुर्भाग्य से ये MySQL या अधिकांश DBMS द्वारा समर्थित नहीं हैं। यदि आप बैच के बाद छात्र-बैच में प्रवेश करते हैं तो आपको ट्रिगर पर EXISTS (क्वेरी) की आवश्यकता हो सकती है। या आप कुछ कॉलम और समग्र FK (विदेशी कुंजी) प्रतिबंध जोड़ सकते हैं।

अब हम एक प्रश्न लिख रहे हैं। हमें ऐसी पंक्तियाँ चाहिए जहाँ:

FOR k.*, t.*, b.*, s.*, sb.* (
    batch = b.id AND teacher = t.name AND student = s.name
AND takes(k.student_id, k.subject_id)
AND teacher(t.id, t.name, t.email, t.subject_id)
AND batch(b.id, b.venue, b.teacher_id, b.date)
AND student(s.id, s.name, s.location)
AND student-batch(sb.id, sb.student_id, sb.batch_id)
AND k.subject_id = t.subject_id
AND t.id = b.teacher_id
AND s.id = k.student_id
AND sb.student_id = k.student_id
AND sb.batch_id = b.id
AND @date = b.date)

ऐसा लगता है कि बाधा अलग-अलग रिटर्न कॉलम और अतिरिक्त लाइनों के साथ भविष्यवाणी करती है। एसक्यूएल का सीधे अनुवाद किया गया है। हम छात्र के नाम प्राप्त करने के लिए छात्र के साथ जुड़ते हैं। हम छात्र-बैच के साथ एक जुड़ाव जोड़ते हैं क्योंकि बाधा इससे निपटती नहीं है; बाधा क्वेरी का उपयोग करने वाले संदर्भ यह जांचते हैं कि छात्र-बैच (student_id, बैच_आईडी) सबरो इसमें हैं या नहीं।

SELECT b.id AS batch, t.name AS teacher, s.name AS student
FROM takes k JOIN teacher t JOIN batch b JOIN student s JOIN student-batch sb
WHERE ... AND @date = date

आप एक चालू संस्करण आज़मा सकते हैं:

SELECT b.id AS Batch, t.name AS Teacher, s.name AS Student
FROM takes k
JOIN teacher t ON k.subject_id = t.subject_id
JOIN batch b ON t.id = b.teacher_id
JOIN ...
WHERE @date = b.date