MySQL + SQL · Lesson 27

DBMS Normalization Examples

एक हल उदाहरण

Normalization समझने का सबसे अच्छा तरीका एक गंदी table लेकर उसे 1NF, 2NF और 3NF से step by step ले जाना है। हम एक student-course table इस्तेमाल करेंगे और हर चरण पर उसे साफ़, संबंधित tables बनते देखेंगे।

💡 एक table अंदर → तीन साफ़ tables बाहर, हर step पर एक अलग समस्या हटाकर।

Unnormalized table

student_id	student_name	courses	dept	dept_head
1	Aman	C1, C2	Science	Dr. Rao
2	Diya	C1	Arts	Ms. Iyer

समस्याएँ: courses एक list रखता है, और dept_head एक ही department के हर student को दोहराता है। इन्हें ठीक करते हैं।

1NF में बदलना

Course list को rows में बाँटकर हर cell एक value बनाइए:

student_id	student_name	course	dept	dept_head
1	Aman	C1	Science	Dr. Rao
1	Aman	C2	Science	Dr. Rao
2	Diya	C1	Arts	Ms. Iyer

अब हर cell atomic है। Key composite (student_id, course) है।

2NF में बदलना

Partial dependencies हटाइए: student_name, dept, dept_head सिर्फ़ student_id पर निर्भर हैं, course पर नहीं। इन्हें बाँटिए:

students(student_id PK, student_name, dept, dept_head)
enrollments(student_id FK, course)

अब student details प्रति student एक बार store होती हैं, हर course को दोहराई नहीं।

3NF में बदलना

Transitive dependency हटाइए: dept_head dept पर निर्भर है, सीधे student_id पर नहीं। इसे बाहर ले जाइए:

students(student_id PK, student_name, dept FK)
departments(dept PK, dept_head)
enrollments(student_id FK, course)

अब department head प्रति department एक बार store होता है। इसे बदलना single-row update है।

अंतिम design

हमने एक गंदी table से शुरू करके तीन साफ़, संबंधित पर ख़त्म किया:

students — प्रति student एक row, एक department से जुड़ी।
departments — प्रति department एक row, उसके head के साथ।
enrollments — कौन student कौन-सा course लेता है।

अब हर तथ्य ठीक एक बार store होता है, तो updates सरल हैं और data कभी ख़ुद से विरोधाभास नहीं कर सकता।

आम गलतियाँ

सीधे 3NF पर कूदना। 1NF, फिर 2NF, फिर 3NF क्रम में कीजिए।
Composite key चूकना। 1NF के बाद key अक्सर दो columns साथ होती है।
दोहराई details छोड़ना। अगर detail दोहराए, कोई dependency अब भी ठीक करनी है।
Foreign keys भूलना। बाँटी tables को FKs से वापस जोड़िए।

सारांश

Step by step normalize कीजिए: 1NF, फिर 2NF, फिर 3NF।
1NF: list cells को single-value rows में बाँटिए।
2NF: key के हिस्से पर निर्भर columns को अपनी table में ले जाइए।
3NF: दूसरे non-key column पर निर्भर columns को बाहर ले जाइए।
परिणाम keys से जुड़ी कई साफ़ tables हैं।

आगे, नियम दोहराइए normalization में, या theory functional dependency में।

अक्सर पूछे जाने वाले प्रश्न (FAQ)

Table को step by step कैसे normalize करते हैं?

गंदी table से शुरू कीजिए, फिर हर normal form क्रम में लगाइए: 1NF (cells atomic और rows unique बनाओ), 2NF (बाँटकर partial dependencies हटाओ), और 3NF (फिर बाँटकर transitive dependencies हटाओ)। हर step साफ़, संबंधित tables देता है।

1NF में बदलते समय क्या बदलता है?

आप कई values वाली किसी भी cell को अलग rows में बाँटते हैं, ताकि हर cell में एक atomic value हो, और पक्का करते हैं हर row unique हो। Row के भीतर दोहराए समूह हट जाते हैं।

2NF में बदलते समय क्या बदलता है?

आप partial dependencies हटाते हैं: कोई column जो composite key के सिर्फ़ हिस्से पर निर्भर हो, उस हिस्से पर keyed नई table में जाता है। यह वही detail कई rows में दोहराना रोकता है।

3NF में बदलते समय क्या बदलता है?

आप transitive dependencies हटाते हैं: कोई non-key column जो दूसरे non-key column पर निर्भर हो, अपनी table में जाता है। जैसे, department head department के साथ बाहर जाता है।

तीनों steps क्यों करें?

हर step एक अलग तरह की redundancy हटाता है। इन्हें क्रम में करना साफ़ design देता है जहाँ हर तथ्य एक बार store होता है, updates सरल हैं, और असंगत duplicate data का ख़तरा नहीं।