मेरे t-sql शिक्षक ने हमें बताया कि हमारे PK कॉलम का नामकरण "Id" बिना किसी और स्पष्टीकरण के बुरा व्यवहार माना जाता है।
पीके कॉलम "आईडी" का नामकरण क्यों बुरा माना जाता है?
मेरे t-sql शिक्षक ने हमें बताया कि हमारे PK कॉलम का नामकरण "Id" बिना किसी और स्पष्टीकरण के बुरा व्यवहार माना जाता है।
पीके कॉलम "आईडी" का नामकरण क्यों बुरा माना जाता है?
जवाबों:
मैं बाहर आकर यह कहने जा रहा हूँ: यह वास्तव में एक बुरा अभ्यास नहीं है (और यदि ऐसा है, तो यह उतना बुरा नहीं है )।
आप तर्क दे सकते हैं (जैसा कि चाड ने बताया है) कि यह निम्नलिखित क्वेरी में त्रुटियों की तरह कर सकता है:
SELECT *
FROM cars car
JOIN manufacturer mfg
ON mfg.Id = car.ManufacturerId
JOIN models mod
ON mod.Id = car.ModelId
JOIN colors col
ON mfg.Id = car.ColorId
लेकिन यह आसानी से अपने टेबल के नाम के लिए छोटे उपनामों का उपयोग न करके कम किया जा सकता है:
SELECT *
FROM cars
JOIN manufacturer
ON manufacturer.Id = cars.ManufacturerId
JOIN models
ON models.Id = cars.ModelId
JOIN colors
ON manufacturer.Id = cars.ColorId
कॉलम नाम का उपयोग करने की तुलना में ALWAYS का 3 अक्षर संक्षिप्तिकरण का अभ्यास मुझे बहुत बुरा लगता है id
। (बिंदु में मामला: जो वास्तव में संक्षिप्त नाम के cars
साथ तालिका का नाम संक्षिप्त car
करेगा? वह क्या सेवा करता है?)
मुद्दा यह है: सुसंगत होना। यदि आपकी कंपनी आईडी का उपयोग करती है और आप सामान्यतः ऊपर त्रुटि करते हैं, तो पूर्ण तालिका नामों का उपयोग करने की आदत डालें। यदि आपकी कंपनी आईडी कॉलम पर प्रतिबंध लगाती है, तो इसे स्ट्राइड में लें और जो भी नामकरण सम्मेलन पसंद करते हैं उसका उपयोग करें।
ऐसी चीज़ों पर ध्यान केंद्रित करने के बजाय उन बुरे कामों पर ध्यान केंद्रित करें, जो बुरे व्यवहार (जैसे कई नेस्टेड सहसंबद्ध उप प्रश्न) हैं। आपके कॉलम "आईडी" के नामकरण का मुद्दा स्वाद के मामले के करीब होने की तुलना में यह एक बुरा अभ्यास है।
संपादकों के लिए एक नोट: इस क्वेरी में त्रुटि जानबूझकर है और इसका उपयोग एक बिंदु बनाने के लिए किया जा रहा है। कृपया संपादन से पहले पूरा उत्तर पढ़ें।
cars
-> car
भगवान का शुक्र है - आपने मेरी उंगलियां बचा लीं)। इसे बहुत गहराई से न पढ़ें।
cars
और manufacturer
। एक बहुवचन है, दूसरा नहीं है। यदि लोग db पर चुनना चाहते हैं, तो यह बुरा अभ्यास है जिसे चुना जाना चाहिए।
क्योंकि जब आपके पास एक विदेशी कुंजी के साथ एक तालिका होती है, तो आप उस विदेशी कुंजी "आईडी" का नाम नहीं दे सकते। आपके पास तालिका का नाम है यह TableId
और फिर आपका जुड़ाव दिखता है
SELECT * FROM cars c JOIN manufacturer m ON m.Id = c.ManufacturerId
और आदर्श रूप से, आपकी स्थिति में प्रत्येक तरफ समान फ़ील्ड नाम होना चाहिए
SELECT * FROM cars c JOIN manufacturer m ON m.ManufacturerId = c.ManufacturerId
जब तक कि मुझे Id को निर्माता नाम के रूप में निरर्थक लगता है, यह कम संभावना बनाता है कि आपके पास अपनी शर्तों में त्रुटियां हैं क्योंकि गलतियां स्पष्ट हैं।
यह आसान लगता है, लेकिन जब आप कई तालिकाओं में शामिल होते हैं, तो यह अधिक संभावना है कि आप एक गलती करेंगे, नीचे एक को ढूंढें ...
SELECT *
FROM cars car
JOIN manufacturer mfg
ON mfg.Id = car.ManufacturerId
JOIN models mod
ON mod.Id = car.ModelId
JOIN colors col
ON mfg.Id = car.ColorId
जबकि उचित नामकरण के साथ, त्रुटि बाहर चिपक जाती है ...
SELECT *
FROM cars car
JOIN manufacturer mfg
ON mfg.ManufacturerId = car.ManufacturerId
JOIN models mod
ON mod.ModelId = car.ModelId
JOIN colors col
ON mfg.ManufacturerId = car.ColorId
उन्हें आईडी नाम देने का एक और कारण यह है कि जब आप कई तालिकाओं की जानकारी के लिए क्वेरी कर रहे होते हैं, तो यह है कि आपको आईडी कॉलम का नाम बदलना होगा ताकि आप उन्हें अलग कर सकें।
SELECT manufacturer.Id as 'ManufacturerId'
,cars.Id as 'CarId'
--etc
FROM cars
JOIN manufacturer
ON manufacturer.Id = cars.Id
सटीक नामों के साथ यह एक मुद्दे से कम है
SELECT * FROM cars c JOIN manufacturer m ON manufacturer.Id = c.ManufacturerId
। मैंने id
वर्षों तक उपयोग किया है और कभी नहीं पाया कि आपने वास्तविक समस्या क्या बताई।
SELECT manufacturer.id FROM ...
। इससे होने वाली हर कठिनाई id
को बहुत आसानी से दूर किया जा सकता है, जिससे यह केवल स्वाद की चीज है।
रूबी की ActiveRecord लाइब्रेरी और Groovy's GORM डिफ़ॉल्ट रूप से सरोगेट कुंजी के लिए "id" का उपयोग करते हैं। मुझे यह अभ्यास पसंद है। प्रत्येक स्तंभ नाम में तालिका नाम की नकल निरर्थक है, लिखने के लिए थकाऊ, और पढ़ने के लिए अधिक थकाऊ।
"नाम" या "आईडी" जैसे सामान्य या प्रमुख स्तंभ नामों को तालिका नाम के साथ उपसर्ग किया जाना चाहिए।
यह अस्पष्टता को दूर करता है, आसानी से खोजता है, इसका मतलब है कि जब तक "ईद" दोनों मानों की आवश्यकता होती है, बहुत कम स्तंभ उपनाम।
कम इस्तेमाल किया या ऑडिट कॉलम या गैर-कुंजी (कहते हैं LastUpdatedDateTime) कोई फर्क नहीं पड़ता
name
और क्यों रुके id
? क्यों हर स्तंभ अपने तालिका नाम के साथ उपसर्ग नहीं करता है? एक उपसर्ग को अनिवार्य करने के लिए उन दो नामों को चुनना मनमाना लगता है। वैचारिक रूप से, आपके पास वैसे भी स्तंभ का संदर्भ रखने के लिए तालिका होनी चाहिए। केवल क्वेरी को स्पष्ट करने के लिए उस तालिका नाम का उपयोग क्यों न करें: Person.Name, Animal.Name, Part.Name, ...
यह धागा मर चुका है, लेकिन मैं यह जोड़ना चाहूंगा कि IMO का उपयोग नहीं करना Id
एक बुरा व्यवहार है। Id
स्तंभ खास है; यह है प्राथमिक कुंजी। किसी भी तालिका में कोई भी विदेशी कुंजी हो सकती है, लेकिन इसमें केवल एक कुंजी हो सकती है जो प्राथमिक है। एक डेटाबेस में जहां सभी प्राथमिक कुंजियों को कहा जाता है , जैसे ही आप तालिका को देखते हैं, आपको पता होता है कि प्राथमिक कुंजी कौन सा कॉलम है।Id
मेरा विश्वास करो, अब महीनों के लिए मैंने हर दिन बड़े डेटाबेस (सेल्सफोर्स) के बहुत सारे काम करते हुए बिताया है और स्कीमा के बारे में मैं सबसे अच्छी बात यह कह सकता हूं कि प्रत्येक तालिका में एक प्राथमिक कुंजी है Id
। मैं आपको आश्वस्त कर सकता हूं कि मैं एक विदेशी कुंजी के लिए प्राथमिक कुंजी में शामिल होने के बारे में बिल्कुल भ्रमित नहीं हूं क्योंकि पीके कहा जाता है Id
। एक और बात जिसका लोगों ने उल्लेख नहीं किया है वह यह है कि तालिकाओं में लंबे मूर्ख नाम हो सकते हैं Table_ThatDoesGood_stuff__c
; यह नाम काफी बुरा है क्योंकि आर्किटेक्ट को सुबह उस टेबल पर लगा एक हैंगओवर था, लेकिन अब आप मुझे बता रहे हैं कि प्राथमिक कुंजी को कॉल न करने के लिए यह बुरा अभ्यास है Table_ThatDoesGood_stuff__cId
(यह याद रखना कि SQL स्तंभ नाम सामान्य स्थिति में संवेदनशील नहीं हैं)।
सच कहूं, तो कंप्यूटर प्रोग्रामिंग सिखाने वाले अधिकांश लोगों के साथ समस्या यह है कि उन्होंने वर्षों में कभी भी उत्पादन कोड की एक पंक्ति नहीं लिखी है, और उन्हें पता नहीं है कि वास्तव में एक काम करने वाला सॉफ्टवेयर इंजीनियर क्या करता है। तब तक प्रतीक्षा करें जब तक आप काम करना शुरू नहीं करते हैं और फिर अपना खुद का मन बनाते हैं जो आपको लगता है कि एक अच्छा विचार है या नहीं।
मैं इसे बुरा व्यवहार नहीं मानता। संगति राजा है, हमेशा की तरह।
मुझे लगता है कि यह सब संदर्भ के बारे में है। अपने दम पर तालिका के संदर्भ में, "आईडी" का ठीक वही अर्थ है जो आप उम्मीद करते हैं, एक लेबल विशिष्ट रूप से इसे दूसरों के खिलाफ पहचानने में मदद करता है जो अन्यथा समान हो सकते हैं (या दिखाई देते हैं) समान।
जॉइन के संदर्भ में, यह आपकी जिम्मेदारी है कि आप इस तरह से जॉन्स का निर्माण करें, जिससे यह आपके और आपकी टीम के लिए पठनीय बन सके। जिस तरह से चीजों को मुश्किल से खराब करना या नामकरण करना संभव है, उसी तरह उपनामों और यहां तक कि टिप्पणियों के प्रभावी उपयोग के साथ एक सार्थक क्वेरी का निर्माण करना भी उतना ही संभव है।
उसी तरह एक जावा वर्ग जिसे 'फू' कहा जाता है, उसके गुण 'फू' से उपसर्ग नहीं होते हैं, अपने टेबल आईडी को तालिका के नामों के साथ उपसर्ग के लिए बाध्य नहीं करते हैं। यह आम तौर पर संदर्भ में स्पष्ट है कि आईडी किसके लिए संदर्भित की जा रही है।
बूम, सवाल का जवाब दिया।
अब अपने शिक्षक को बताएं कि SO खराब डेटाबेस डिज़ाइन का अभ्यास करता है।
PostTypeId -> PostTypes.Id
:; AcceptedAnswerId -> Answers.Id
; OwnerUserId -> Users.Id
। ऐसा अभ्यास क्यों किया जाना चाहिए जो उस आसान को 'बुरा' माना जाए?
यह मेज पर एक प्राकृतिक जुड़ाव प्रदर्शन करने के लिए कठिन (और भ्रामक) बनाता है, इसलिए, हाँ, यह बहुत बुरा है अगर बुरा नहीं है।
नेचुरल जॉइन SQL लोर (यानी रिलेशनल अलजेब्रा) की एक प्राचीन कलाकृति है जो आपने इनमें से किसी एक: artifact डेटाबेस डेटाबेस में देखी होगी। मेरा मतलब है कि नैचुरल ज्वाइन एक नया फँसा हुआ एसक्यूएल विचार नहीं है, भले ही यह डीबीएमएस के लिए हमेशा के लिए लग रहा है इसे लागू किया गया है, इसलिए इसे लागू करने के लिए आपके लिए एक नया फँसा हुआ विचार नहीं है, यह आपको अनदेखा करने के लिए अनुचित भी हो सकता है। आजकल इसका अस्तित्व है।
ठीक है, यदि आप अपने सभी प्राथमिक कुंजी की आईडी का नाम देते हैं, तो आप प्राकृतिक जुड़ने की सहजता और सरलता खो देते हैं। select * from dudes natural join cars
लिखा जा करने की आवश्यकता होगी select * from dudes inner join cars where cars.dudeid = dudes.id
या select * from dudes inner join cars where dudes.carid = cars.id
। यदि आप प्राकृतिक रूप से जुड़ने में सक्षम हैं, तो आप इस बात को नजरअंदाज कर सकते हैं कि वास्तव में क्या संबंध है, जो, मेरा मानना है कि, बहुत बढ़िया है।
एक ऐसी स्थिति है जहां हर टेबल पर "आईडी" चिपके रहना सबसे अच्छा विचार नहीं है: USING
कीवर्ड, यदि यह समर्थित है। हम इसका उपयोग अक्सर MySQL में करते हैं।
उदाहरण के लिए, यदि आपके पास fooTable
कॉलम है fooTableId
और barTable
विदेशी कुंजी है fooTableId
, तो आपके प्रश्नों का निर्माण इस प्रकार किया जा सकता है:
SELECT fooTableId, fooField1, barField2 FROM fooTable INNER JOIN barTable USING (fooTableId)
यह न केवल टाइपिंग को बचाता है, बल्कि विकल्प की तुलना में बहुत अधिक पठनीय है:
SELECT fooTable.Id, fooField1, barField2 FROM fooTable INNER JOIN barTable ON (fooTable.Id = barTable.foTableId)
USING
कीवर्ड पोस्टग्रेज / mysql / sqlite डेटाबेस द्वारा समर्थित है, जिसका अर्थ है कम टाइपिंग जो कुछ अन्य उत्तर सूची का उपयोग करने के कारण के रूप में करता है id
, और अंत में मेरे व्यक्तिपरक राय में अधिक पठनीय है।
सिर्फ अपने शिक्षक से ही क्यों न पूछें?
इस बारे में सोचें, जब आपके सभी टेबल पीके कॉलम का नाम दिया गया है, तो ID
यह उन्हें विदेशी कुंजी के रूप में एक बुरे सपने का उपयोग करता है।
स्तंभ नामों को शब्दार्थ रूप से महत्वपूर्ण होना चाहिए। ID
जेनेरिक है।
id
अकेले कुछ भी मतलब नहीं है, विशेष रूप से एक अन्य तालिका के लिए एक विदेशी कुंजी के संदर्भ में। यह classes
अच्छा बुनियादी मौलिक संबंध डेटाबेस डिजाइन के साथ करने के लिए और सब कुछ करने के लिए कुछ भी नहीं है ।
table.id
एक id
क्षेत्र का जिक्र करने के लिए एक पूरी तरह से स्वीकार्य तरीका है । फ़ील्ड नाम को तालिका नाम के साथ उपसर्ग करना निरर्थक है।
निम्नलिखित कारणों से आईडी खराब है:
यदि आप बहुत सारे रिपोर्टिंग क्वेश्चन करते हैं तो आपको हमेशा कॉलम देखना होगा अगर आप दोनों को देखना चाहते हैं। तो यह समय की बर्बादी बन जाता है जब आप इसे ठीक से नाम देना शुरू कर सकते हैं। ये जटिल प्रश्न काफी कठिन हैं (मैं ऐसे प्रश्न लिखता हूं जो अनावश्यक काम करने के अतिरिक्त बोझ के बिना सैकड़ों लाइनें लंबी हो सकती हैं)।
यह कोड त्रुटियों के कारण है। यदि आप एक डेटाबेस का उपयोग करते हैं जो प्राकृतिक जुड़ने का उपयोग करने की अनुमति देता है (ऐसा नहीं है कि मुझे लगता है कि आपको कभी भी इसका उपयोग करना चाहिए लेकिन जब सुविधाएँ उपलब्ध होंगी तो कोई उनका उपयोग करेगा), यदि आप एक डेवलपर को प्राप्त करते हैं तो आप गलत उपयोग में शामिल होंगे।
यदि आप एक जटिल क्वेरी बनाने के लिए j नकल की नकल कर रहे हैं, तो आप जिस व्यक्ति को चाहते हैं, उसके लिए उपनाम बदलना और एक गलत जुड़ाव भूलना आसान है। यदि प्रत्येक आईडी का नाम तालिका के नाम पर है, तो आपको आमतौर पर एक सिंटैक्स त्रुटि मिलेगी। अगर पीएपीके नाम और एफके नाम मैच में शामिल हो तो यह आसान है कि ज्वाइन आईएनए जटिल क्वेरी गलत है।
ID
मुझे बिल्कुल नहीं समझाते।
कुछ उत्तर हैं जो दृष्टिकोण को मैं "आईडी" का उपयोग नहीं करने के सबसे महत्वपूर्ण कारण पर विचार करेंगे क्योंकि तालिका में प्राथमिक कुंजी के लिए कॉलम नाम: अर्थात् स्थिरता और कम अस्पष्टता।
हालांकि, मेरे लिए प्रमुख लाभ रखरखाव प्रोग्रामर द्वारा महसूस किया जाता है, विशेष रूप से एक जो मूल विकास के साथ शामिल नहीं था। यदि आपने व्यक्ति तालिका में आईडी के लिए "पर्सिड" नाम का उपयोग किया है और लगातार उस नाम को एक विदेशी कुंजी के रूप में उपयोग किया है, तो स्कीमा के खिलाफ क्वेरी लिखने के लिए यह पता लगाना तुच्छ है कि क्या पर्सिड के पास उस "पर्सिड" का पता लगाए बिना है। यह एक विदेशी कुंजी है जब नाम का उपयोग किया जाता है। याद रखें, सही या गलत, विदेशी कुंजी संबंध हमेशा सभी परियोजनाओं में लागू नहीं होते हैं।
एक किनारे का मामला है, जहां एक टेबल के लिए एक ही टेबल पर दो विदेशी कुंजियों की आवश्यकता हो सकती है, लेकिन ऐसे मामलों में मैं मूल कुंजी नाम को कॉलम के प्रत्यय के नाम के रूप में रखूंगा, इसलिए वाइल्डकार्ड मैच,% पर्सिड, आसानी से मिल सकता है उन उदाहरणों के रूप में अच्छी तरह से।
हां, यह बहुत कुछ "आईडी" होने के मानक के द्वारा पूरा किया जा सकता है और हमेशा इसे "टेबलनेम" के रूप में उपयोग करने के लिए जाना जा सकता है, लेकिन इसके लिए दोनों को यह जानने की आवश्यकता है कि अभ्यास जगह पर है और मूल डेवलपर्स के आधार पर एक कम के साथ पालन करने के लिए सहज मानक अभ्यास।
हालांकि कुछ लोगों ने कहा है कि लंबे कॉलम के नामों को लिखने के लिए कुछ अतिरिक्त कुंजी स्ट्रोक की आवश्यकता होती है, मैं कहता हूं कि कोड लिखना कार्यक्रम के सक्रिय जीवन का केवल एक छोटा सा अंश है। यदि डेवलपर कीस्ट्रोक्स को बचाना लक्ष्य था, तो टिप्पणियों को कभी नहीं लिखा जाना चाहिए।
किसी के रूप में, जिसने सैकड़ों वर्षों से बड़ी परियोजनाओं को बनाए रखने में कई साल बिताए हैं, मैं दृढ़ता से तालिकाओं की कुंजी के लिए संगत नामों को प्राथमिकता दूंगा।
Companies
टेबल में 2 विदेशी चाबियां हैं Persons
। एक कंपनी के अध्यक्ष का प्रतिनिधित्व करता है; अन्य कंपनी के कोषाध्यक्ष का प्रतिनिधित्व करता है। क्या आप वास्तव में कॉलम PersonID1
और कहेंगे PersonID2
? यह उन्हें कॉल करने के लिए PresidentID
और अधिक विवरणात्मक होगा TreasurerID
। मुझे पढ़ने में बहुत आसान लगता inner join Person AS Presidents ON Company.PresidentID = Presidents.ID
हैinner join Person AS Person1 ON Company.PersonID1 = Person1.PersonID
CompanyOfficer
या CompanyPerson
तालिका होगी जो रिश्ते की प्रकृति के बारे में अतिरिक्त जानकारी के बीच Company
और Person
साथ कई-से-कई संबंधों की अनुमति देती है । यदि मुझे इसे Company
तालिका के भीतर लागू करना है , तो मैं अतिरिक्त विवरणक को जोड़ते हुए कॉलम के नामों का उपयोग करूँगा PresidentPersonID
और नाम TreasurerPersonID
के * PersonID भाग को संरक्षित करूंगा। inner join Person as Presidents on Company.PresidentPersonID = Presidents.PersonID
आईडी को प्राथमिक कुंजी क्षेत्र के रूप में उपयोग करने का अभ्यास उस अभ्यास की ओर जाता है जहां आईडी को हर तालिका में जोड़ा जाता है। बहुत सी तालिकाओं में पहले से ही अनूठी जानकारी होती है जो विशिष्ट रूप से एक रिकॉर्ड की पहचान करती है। प्राथमिक कुंजी के रूप में THAT का उपयोग करें न कि आपके द्वारा प्रत्येक तालिका में जोड़ा गया एक आईडी फ़ील्ड। यह संबंधपरक डेटाबेस की नींव में से एक है।
और यही कारण है कि आईडी का उपयोग करना बुरा व्यवहार है: आईडी अक्सर केवल एक ऑटोइंकोर की जानकारी नहीं होती है।
निम्नलिखित तालिकाओं पर विचार करें:
PK id | Countryid | Countryname
1 | 840 | United States
2 | 528 | the Netherlands
इस तालिका के साथ गलत क्या है कि यह उपयोगकर्ता को एक और लाइन जोड़ने में सक्षम बनाता है: संयुक्त राज्य अमेरिका, देश कोड 840 के साथ। यह सिर्फ संबंधपरक अखंडता को तोड़ता है। आप व्यक्तिगत कॉलम पर विशिष्टता लागू कर सकते हैं, या आप पहले से उपलब्ध प्राथमिक कुंजी का उपयोग कर सकते हैं:
PK Countryid | Countryname
840 | United States
528 | the Netherlands
इस तरह आप प्राथमिक कुंजी के रूप में आपके पास पहले से मौजूद जानकारी का उपयोग करते हैं, जो कि रिलेशनल डेटाबेस डिज़ाइन के केंद्र में है।
मुझे नहीं लगता कि अगर यह ठीक से उपयोग किया जाता है तो यह एक बुरा अभ्यास है। "आईडी" नामक एक ऑटो-इन्क्रिमेंटिंग आईडी फ़ील्ड होना आम है जिसे आपको कभी भी स्पर्श नहीं करना है, और एप्लिकेशन के लिए एक मित्र पहचानकर्ता का उपयोग करना है। कोड को लिखना थोड़ा बोझिल हो सकता है from tableA a inner join tableB b on a.id = b.a_id
लेकिन उस कोड को टाल दिया जा सकता है।
एक व्यक्तिगत प्राथमिकता के रूप में, मैं इकाई के नाम के साथ आईडी को उपसर्ग करता हूं, लेकिन Id
अगर यह पूरी तरह से डेटाबेस द्वारा नियंत्रित किया जाता है , तो मैं केवल उपयोग करने के साथ एक वास्तविक मुद्दा नहीं देखता हूं ।
आईडी काफी आम है, कि मुझे नहीं लगता कि यह किसी को भ्रमित करेगा। आप हमेशा तालिका जानना चाहते हैं। एक टेबल / उपनाम के बिना उत्पादन कोड में फ़ील्ड नाम डालना एक बुरा अभ्यास है। यदि आप जल्दी से तदर्थ प्रश्नों को टाइप करने में सक्षम होने के बारे में चिंतित हैं, तो आप अपने दम पर हैं।
बस आशा है कि कोई भी एक sql डेटाबेस विकसित नहीं करता है जहाँ ID एक आरक्षित शब्द है।
CREATE TABLE CAR (ID);
क्षेत्र का नाम, प्राथमिक कुंजी, और ऑटो वेतन वृद्धि की देखभाल 1 से 1 अच्छे छोटे 2 वर्ण पैकेज में 1 से शुरू करता है। ओह, और मैंने इसे CARS कहा होगा, लेकिन अगर हम कुंजी स्ट्रोक पर बचत करने जा रहे हैं और कौन वास्तव में सोचता है कि CAR नामक तालिका केवल एक के पास है?
Car
एक का प्रतिनिधित्व करती है, Table
जहां प्रत्येक Row
एकल का प्रतिनिधित्व करता है Car
। Cars
सिमेंटिक को बदलने में कॉल करना और औपचारिक संबंधपरक सिद्धांत मूल प्राचार्यों की समझ का पूर्ण अभाव दर्शाता है। रेल किसी का भी एक प्रमुख उदाहरण है जो खतरनाक होना जानता था ।
इस सवाल को बार-बार पीटा गया, लेकिन मुझे लगा कि मैं भी अपनी राय दूंगा।
मैं आईडी का उपयोग इस बात के लिए करता हूं कि प्रत्येक तालिका के लिए पहचानकर्ता है, इसलिए जब मैं किसी तालिका में शामिल होता हूं और मुझे प्राथमिक कुंजी की आवश्यकता होती है तो मैं स्वचालित रूप से प्राथमिक कुंजी में शामिल हो जाता हूं।
आईडी फ़ील्ड एक स्वत: अंकन है, अहस्ताक्षरित (जिसका अर्थ है कि मुझे इसका मूल्य कभी निर्धारित नहीं करना है और यह नकारात्मक नहीं हो सकता है)
विदेशी कुंजियों के लिए, मैं टैबलेनमिड (फिर से स्टाइल की बात) का उपयोग करता हूं, लेकिन मैं जिस प्राथमिक कुंजी से जुड़ता हूं वह तालिका का आईडी फ़ील्ड है, इसलिए स्थिरता का मतलब है कि मैं हमेशा आसानी से प्रश्नों की जांच कर सकता हूं
आईडी छोटी है और प्यारी भी
अतिरिक्त सम्मेलन - सभी तालिका और स्तंभ नामों के लिए निचले मामले का उपयोग करें, इसलिए मामले के कारण कोई समस्या नहीं होनी चाहिए
एक और बात पर विचार करना है कि यदि प्राथमिक कुंजी नाम विदेशी कुंजी नाम से अलग है, तो कुछ तृतीय पक्ष टूल का उपयोग करना संभव नहीं है।
उदाहरण के लिए, आप अपने स्कीमा को Visio जैसे टूल में लोड करने में असमर्थ होंगे और यह सटीक ERD का उत्पादन करेगा।
मुझे लगता है कि लोग यहां हर पहलू को बहुत कवर करते हैं, लेकिन मैं यह जोड़ना चाहता हूं कि "आईडी" नहीं है और इसे "पहचानकर्ता" के रूप में नहीं पढ़ा जाना चाहिए, यह "इंडेक्स" का अधिक है और निश्चित रूप से यह पंक्ति की पहचान का वर्णन या वर्णन नहीं करता है। (हो सकता है कि मैंने यहाँ गलत शब्दों का इस्तेमाल किया हो, कृपया मुझे सही कर दो)
यह अधिक या कम है कि लोग टेबल डेटा को कैसे पढ़ते हैं और वे अपना कोड कैसे लिखते हैं। मैं व्यक्तिगत रूप से और सबसे अधिक संभावना है कि यह सबसे लोकप्रिय तरीका है जिसे मैं अधिक बार देखता हूं कि कोडर्स पूरा संदर्भ लिखते हैं table.id
, भले ही उन्हें यूनियन या / और जॉइन करने की आवश्यकता न हो। उदाहरण के लिए:
SELECT cars.color, cars.model FROM cars WHERE cars.id = <some_var>
इस तरह से आप इसे अंग्रेजी में "मुझे उस कार का रंग और मॉडल दें जो गिने हुए हैं।" और न कि "मुझे उस कार का रंग और मॉडल दें जिसे नंबर के रूप में पहचाना जाता है।" आईडी किसी भी तरह से कार का प्रतिनिधित्व नहीं करता है, यह केवल कार का इंडेक्स है, यदि आप करेंगे तो एक सीरियल नंबर। जैसे जब आप किसी एरे से तीसरा एलिमेंट लेना चाहते हैं।
इसलिए, यह जोड़ने के लिए कि मैं क्या जोड़ना चाहता था, यह केवल वरीयता का मामला है और एसक्यूएल पढ़ने का वर्णित तरीका सबसे लोकप्रिय है।
हालाँकि, कुछ ऐसे मामले हैं, जिनका उपयोग नहीं किया जाता है, जैसे कि (कहीं अधिक दुर्लभ उदाहरण) जब आईडी एक स्ट्रिंग है जो वास्तव में वर्णन कर रहा है। उदाहरण के लिए id = "RedFordMustang1970"
या ऐसा ही कुछ। मुझे वास्तव में उम्मीद है कि मैं कम से कम विचार प्राप्त करने के लिए इसे समझा सकता हूं।