sql - संग्रहीत प्रक्रियाओं के लिए आपका नामकरण सम्मेलन क्या है?




stored-procedures naming-conventions (12)

GetXXX - XXX को @ID पर आधारित करता है

GetAllXXX - सभी XXX हो जाता है

PutXXX - पारित होने पर XXX डालें @ID -1 है; अन्य अद्यतन

DelXXX - XXX को @ID पर आधारित हटा देता है

मैंने संग्रहित प्रक्रियाओं के नामकरण के लिए विभिन्न नियमों को देखा है।

कुछ लोग sprp नाम को usp_ के साथ उपसर्ग करते हैं, अन्य लोग ऐप नाम के संक्षिप्त नाम के साथ, और फिर भी स्वामी नाम के साथ अन्य। आपको SQL सर्वर में SP_ का उपयोग नहीं करना चाहिए जबतक कि आप वास्तव में इसका मतलब नहीं लेते।

कुछ क्रिया के साथ proc नाम शुरू करें (प्राप्त करें, जोड़ें, सहेजें, निकालें)। अन्य इकाई नाम (ओं) पर जोर देते हैं।

सैकड़ों sprocs के साथ एक डेटाबेस पर, जब आप सोचते हैं कि एक पहले से मौजूद है तो चारों ओर स्क्रॉल करना और उपयुक्त स्पोक ढूंढना बहुत मुश्किल हो सकता है। नामकरण सम्मेलन एक स्पोक को ढूंढने में आसान बना सकते हैं।

क्या आप एक नामकरण सम्मेलन का उपयोग करते हैं? कृपया इसका वर्णन करें, और समझाएं कि आप इसे अन्य विकल्पों पर क्यों पसंद करते हैं।

उत्तरों का सारांश:

  • हर कोई नामकरण की स्थिरता का समर्थन करता प्रतीत होता है, कि हर किसी के लिए एक ही नामकरण सम्मेलन का उपयोग करना अधिक महत्वपूर्ण हो सकता है, जिसका उपयोग किसी विशेष रूप से किया जाता है।
  • उपसर्ग: जबकि बहुत से लोग usp_ या कुछ समान (लेकिन शायद ही कभी sp_) का उपयोग करते हैं, कई अन्य डेटाबेस या ऐप नाम का उपयोग करते हैं। रिपोर्टिंग या कार्यों के लिए इस्तेमाल किए गए सामान्य सीआरयूडी स्पॉक्स को अलग करने के लिए एक चालाक डीबीए जीन, आरपीटी और टीस्क का उपयोग करता है।
  • Verb + Noun Noun + Verb से थोड़ा अधिक लोकप्रिय प्रतीत होता है। कुछ लोग क्रियाओं के लिए एसक्यूएल कीवर्ड (चयन, सम्मिलित करें, अद्यतन करें, हटाएं) का उपयोग करते हैं, जबकि अन्य गैर-एसक्यूएल क्रियाएं (या उनके लिए संक्षेप) जैसे गेट और एड का उपयोग करते हैं। कुछ सिंगलर और बहुवचन संज्ञाओं के बीच अंतर करते हैं यह इंगित करने के लिए कि एक या कई रिकॉर्ड पुनर्प्राप्त किए जा रहे हैं या नहीं।
  • अंत में एक अतिरिक्त वाक्यांश सुझाया जाता है, जहां उचित हो। GetCustomerById, GetCustomerBySaleDate।
  • कुछ लोग नाम सेगमेंट के बीच अंडरस्कोर का उपयोग करते हैं, और कुछ अंडरस्कोर से बचते हैं। app_ Get_Customer बनाम appGetCustomer - मुझे लगता है कि यह पठनीयता की बात है।
  • स्पॉक्स के बड़े संग्रह ओरेकल पैकेज या प्रबंधन स्टूडियो (एसक्यूएल सर्वर) समाधान और परियोजनाओं, या एसक्यूएल सर्वर स्कीमा में अलग किया जा सकता है।
  • अचूक संक्षेप से बचा जाना चाहिए।

मैं जवाब क्यों चुनता हूं: बहुत सारे अच्छे प्रतिक्रियाएं हैं I आप सभी को धन्यवाद! जैसा कि आप देख सकते हैं, केवल एक को चुनना बहुत कठिन होगा। मैंने जो चुना वह मेरे साथ गूंज गया। मैंने उसी मार्ग का पालन किया है जिसका वह वर्णन करता है - वर्ब + नून का उपयोग करने की कोशिश कर रहा है और फिर ग्राहक पर लागू होने वाले सभी स्पॉक्स खोजने में सक्षम नहीं है।

मौजूदा स्पोक का पता लगाने में सक्षम होने के नाते, या यह निर्धारित करने के लिए कि कोई भी मौजूद है, बहुत महत्वपूर्ण है। गंभीर समस्या तब उत्पन्न हो सकती है जब कोई अनजाने में किसी अन्य नाम के साथ डुप्लिकेट स्पोक बनाता है।

चूंकि मैं आमतौर पर सैकड़ों स्पॉक्स के साथ बहुत बड़े ऐप्स पर काम करता हूं, इसलिए मुझे सबसे आसान-खोजने वाली नामकरण विधि की प्राथमिकता है। एक छोटे से ऐप के लिए, मैं Verb + Noun का समर्थन कर सकता हूं, क्योंकि यह विधि नामों के लिए सामान्य कोडिंग सम्मेलन का पालन करता है।

वह बहुत उपयोगी usp_ के बजाय ऐप नाम के साथ उपसर्ग करने की भी वकालत करता है। जैसा कि कई लोगों ने बताया, कभी-कभी डेटाबेस में कई ऐप्स के लिए स्पॉक्स होते हैं। इसलिए, ऐप नाम से उपसर्ग करने से स्पॉक्स को अलग करने में मदद मिलती है और डीबीए और अन्य लोगों को यह निर्धारित करने में मदद मिलती है कि किस ऐप के लिए स्पोक का उपयोग किया जाता है।


अनुप्रयोग prefix_ ऑपरेशन prefix_ डेटाबेस ऑब्जेक्ट्स का विवरण शामिल है (अंडरस्कोर के बीच की जगहों को घटाएं - उन्हें उनके लिए रिक्त स्थान दिखाना था)

ऑपरेशन उपसर्ग हम उपयोग करते हैं -

  • " प्राप्त करें " - एक रिकॉर्डसेट देता है
  • " इन्स " - डेटा सम्मिलित करता है
  • "अद्यतन" - अद्यतन डेटा
  • " डेल " - डेटा हटा देता है

जैसे

wmt_ ins _ ग्राहक _ विवरण

"कार्यबल प्रबंधन उपकरण, ग्राहक तालिका में विवरण डालें"

फायदे

एक ही आवेदन से संबंधित सभी संग्रहीत प्रक्रियाओं को नाम से समूहीकृत किया जाता है। समूह के भीतर, संग्रहीत प्रक्रियाएं जो समान प्रकार के ऑपरेशन (जैसे आवेषण, अद्यतन इत्यादि) को एक साथ समूहीकृत करती हैं।

यह प्रणाली लगभग हमारे पास अच्छी तरह से काम करती है। मेरे सिर के शीर्ष से एक डेटाबेस में 1000 संग्रहीत प्रक्रियाएं।

अब तक इस दृष्टिकोण के किसी भी नुकसान में नहीं आया है।


छोटे डेटाबेस के लिए, मैं uspTableNameOperationName का उपयोग करता हूं, उदाहरण के लिए uspCustomerCreate, uspCustomerDelete, आदि। यह 'मुख्य' इकाई द्वारा समूहबद्ध करने में सुविधा प्रदान करता है।

बड़े डेटाबेस के लिए, एक स्कीमा या सबसिस्टम नाम जोड़ें, उदाहरण के लिए उन्हें प्राप्त करने के लिए प्राप्त करना, खरीदना आदि। (चूंकि SQL सर्वर उन्हें वर्णानुक्रम में प्रदर्शित करना पसंद करता है)

मैं स्पष्टता के लिए नामों में संक्षेप से बचने की कोशिश करता हूं, और परियोजना पर नए लोगों को आश्चर्य नहीं करना चाहिए कि 'यूएनएआईसीएफई' क्या है क्योंकि स्पोक का नाम uspUsingNoAbbreviationsIncreasesClarityForEveryone)


मुझे नहीं लगता कि यह वास्तव में मायने रखता है कि आपका उपसर्ग इतना लंबा है कि आप तार्किक और सुसंगत हैं। व्यक्तिगत रूप से मैं उपयोग करता हूं

spu_ [कार्रवाई विवरण] [प्रक्रिया विवरण]

जहां क्रिया विवरण सामान्य क्रियाओं की एक छोटी सी श्रृंखला में से एक है जैसे प्राप्त, सेट, संग्रह, सम्मिलित, हटाएं आदि। प्रक्रिया विवरण कुछ छोटा लेकिन वर्णनात्मक है, उदाहरण के लिए

spu_archiveCollectionData 

या

spu_setAwardStatus

मैं अपने कार्यों को समान रूप से नाम देता हूं, लेकिन udf_ के साथ उपसर्ग

मैंने लोगों को प्रक्रिया नामकरण के लिए छद्म-हंगेरियन नोटेशन का उपयोग करने का प्रयास किया है, जो मेरी राय में प्रकट होने से कहीं अधिक छुपाता है। जब तक मैं अपनी प्रक्रियाओं को वर्णानुक्रम में सूचीबद्ध करता हूं, तब तक मैं उन्हें कार्यक्षमता द्वारा समूहीकृत देख सकता हूं, फिर मेरे लिए आदेश और अनावश्यक कठोरता के बीच मीठा स्थान लगता है


मेरे आखिरी प्रोजेक्ट के लिए मैंने usp_ [एक्शन] [ऑब्जेक्ट] [प्रक्रिया] का उपयोग किया, उदाहरण के लिए, usp_AddProduct या usp_GetProductList, usp_GetProductDetail। हालांकि अब डेटाबेस 700 प्रक्रियाओं के साथ है, यह एक विशिष्ट वस्तु पर सभी प्रक्रियाओं को खोजने के लिए बहुत कठिन हो जाता है। उदाहरण के लिए अब मुझे उत्पाद जोड़ने के लिए 50 विषम प्रक्रियाओं को खोजना है, और प्राप्त करने के लिए 50 विषमताएं तलाशना है।

इस वजह से मैं अपने नए एप्लिकेशन में ऑब्जेक्ट द्वारा प्रक्रिया नामों को समूहबद्ध करने की योजना बना रहा हूं, मैं भी यूएसपी छोड़ रहा हूं क्योंकि मुझे लगता है कि यह कुछ हद तक अनावश्यक है, मुझे इसकी प्रक्रिया को बताने के अलावा, मैं कुछ नाम से कटौती कर सकता हूं प्रक्रिया ही।

इस प्रकार नया प्रारूप है

[App]_[Object]_[Action][Process]

App_Tags_AddTag
App_Tags_AddTagRelations
App_Product_Add 
App_Product_GetList
App_Product_GetSingle

यह बाद में आसान खोज के लिए चीजों को समूहबद्ध करने में मदद करता है, खासकर यदि बड़ी संख्या में स्पॉक्स हैं।

जहां एक से अधिक ऑब्जेक्ट का उपयोग किया जाता है, मुझे लगता है कि अधिकांश उदाहरणों में प्राथमिक और द्वितीयक वस्तु होती है, इसलिए प्राथमिक वस्तु सामान्य आवृत्ति में उपयोग की जाती है, और माध्यमिक को प्रक्रिया अनुभाग में प्रस्तुत किया जाता है, उदाहरण के लिए App_Product_AddAttribute।


मैं धागे के अंत में शामिल हो गया लेकिन मैं यहां अपना जवाब दर्ज करना चाहता हूं:

मेरी पिछली दो परियोजनाओं में अलग-अलग रुझान हैं, जिनमें से एक हमने उपयोग किया था:

डेटा प्राप्त करने के लिए: s <tablename> _G
डेटा हटाने के लिए: s <tablename> _D
डेटा डालने के लिए: s <tablename> _I
डेटा अपडेट करने के लिए: s <tablename> _U

डीटी शब्द का उपसर्ग करके इस नामकरण सम्मेलन का फ्रंट-एंड भी किया जाता है।

उदाहरण:

exec sMedicationInfo_G
exec sMedicationInfo_D
exec sMedicationInfo_I
exec sMedicationInfo_U

हमारे आवेदन में उपरोक्त नामकरण सम्मेलनों की सहायता से हमारे पास नाम याद रखने के लिए एक अच्छा और आसान है।

जबकि दूसरी परियोजना में हमने लील अंतर के साथ समान नामकरण सम्मेलनों का उपयोग किया:

डेटा प्राप्त करने के लिए: sp_ <tablename> जी
डेटा हटाने के लिए: sp_ <tablename> डी
डेटा डालने के लिए: sp_ <tablename> I
डेटा अपडेट करने के लिए: sp_ <tablename> यू

उदाहरण:

exec sp_MedicationInfoG
exec sp_MedicationInfoD
exec sp_MedicationInfoI
exec sp_MedicationInfoU

मैं हमेशा संकुल में संग्रहित प्रक्रियाओं को समाहित करता हूं (मैं काम पर ओरेकल का उपयोग कर रहा हूं)। इससे अलग वस्तुओं की संख्या कम हो जाएगी और कोड पुन: उपयोग में मदद मिलेगी।

नामकरण सम्मेलन स्वाद का विषय है और परियोजना शुरू होने पर आपको अन्य सभी डेवलपर्स के साथ सहमत होना चाहिए।


मैं हमेशा उपयोग करता हूं:

यूएसपी [टेबल नाम] [एक्शन] [अतिरिक्त विवरण]

"TblUser" नामक एक टेबल को देखते हुए, जो मुझे देता है:

  • uspUserCreate
  • uspUserSelect
  • uspUserSelectByNetworkID

प्रक्रियाओं को तालिका नाम और कार्यक्षमता द्वारा क्रमबद्ध रूप से क्रमबद्ध किया जाता है, इसलिए यह देखना आसान है कि मैं किसी भी तालिका में क्या कर सकता हूं। उपसर्ग "usp" का उपयोग करने से मुझे पता चलता है कि मैं क्या कह रहा हूं यदि मैं (उदाहरण के लिए) 1000-लाइन प्रक्रिया लिख ​​रहा हूं जो अन्य प्रक्रियाओं, एकाधिक तालिकाओं, कार्यों, विचारों और सर्वरों के साथ इंटरैक्ट करता है।

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


वर्तमान के लिए, मैं जिस पर काम कर रहा हूं, हमारे पास एक उपसर्ग है जो एप्लिकेशन नाम (चार लोअरकेस अक्षरों) की पहचान करता है। इसका कारण यह है कि हमारा आवेदन उसी डेटाबेस में विरासत अनुप्रयोग के साथ सह-अस्तित्व में सक्षम होना चाहिए, इसलिए उपसर्ग एक जरूरी है।

अगर हमारे पास विरासत बाधा नहीं थी, तो मुझे पूरा यकीन है कि हम उपसर्ग का उपयोग नहीं करेंगे।

उपसर्ग के बाद हम आम तौर पर एक क्रिया के साथ एसपी नाम शुरू करते हैं जो वर्णन करता है कि प्रक्रिया क्या करती है, और उसके बाद उस इकाई का नाम जिसे हम संचालित करते हैं। इकाई नाम के बहुवचन की अनुमति है - हम पठनीयता पर जोर देने की कोशिश करते हैं, ताकि यह स्पष्ट हो कि प्रक्रिया अकेले नाम से क्या करती है।

हमारी टीम पर विशिष्ट संग्रहीत प्रक्रिया नाम होंगे:

shopGetCategories
shopUpdateItem

सिस्टम हंगेरियन (उपरोक्त "यूएसपी" उपसर्ग की तरह) मुझे शर्मिंदा बनाता है।

हम अलग-अलग, समान रूप से संरचित डेटाबेस में कई संग्रहीत प्रक्रियाओं को साझा करते हैं, इसलिए डेटाबेस-विशिष्ट वाले लोगों के लिए, हम डेटाबेस नाम के उपसर्ग का उपयोग करते हैं; साझा प्रक्रियाओं में कोई उपसर्ग नहीं है। मुझे लगता है कि अलग-अलग स्कीमा का उपयोग करना कुछ हद तक बदसूरत उपसर्गों से छुटकारा पाने का विकल्प हो सकता है।

उपसर्ग के बाद वास्तविक नाम फ़ंक्शन नामकरण से शायद ही अलग है: आम तौर पर "एड", "सेट", "जेनरेट", "गणना करें", "हटाएं" इत्यादि जैसे क्रिया, कई अन्य विशिष्ट संज्ञाएं जैसे कि "उपयोगकर्ता" "," डेली रेवेन्यूज ", और इसी तरह।

चींटी की टिप्पणी का जवाब:

  1. तालिका और दृश्य के बीच का अंतर उन लोगों के लिए प्रासंगिक है जो डेटाबेस स्कीमा तैयार करते हैं, न कि जो इसकी सामग्री को एक्सेस या संशोधित करते हैं। स्कीमा विनिर्देशों की आवश्यकता के दुर्लभ मामले में, यह खोजने में काफी आसान है। आकस्मिक चयन क्वेरी के लिए, यह अप्रासंगिक है। असल में, मैं तालिकाओं का इलाज करने और एक बड़े लाभ के रूप में विचार करने में सक्षम होने का संबंध रखता हूं।
  2. कार्यों और संग्रहीत प्रक्रियाओं के विपरीत, किसी तालिका या दृश्य का नाम किसी क्रिया से शुरू होने की संभावना नहीं है, या एक या अधिक संज्ञाओं के अलावा कुछ भी हो।
  3. एक फ़ंक्शन को स्कीमा उपसर्ग को कॉल करने की आवश्यकता होती है। वास्तव में, कॉल सिंटैक्स (जिसे हम वैसे भी उपयोग करते हैं) एक फ़ंक्शन और संग्रहीत प्रक्रिया के बीच बहुत अलग है। लेकिन अगर यह नहीं था, तो 1 जैसा ही लागू होगा: यदि मैं कार्यों और संग्रहीत प्रक्रियाओं का इलाज कर सकता हूं, तो मुझे क्यों नहीं चाहिए?

SQL सर्वर में sp_ उपसर्ग समस्या के बारे में कुछ स्पष्टीकरण यहां दिया गया है।

उपसर्ग SP_ के साथ नामित संग्रहीत प्रक्रियाएं मास्टर डेटाबेस में संग्रहीत सिस्टम स्पॉक्स हैं।

यदि आप अपना उपसर्ग इस उपसर्ग देते हैं, तो SQL सर्वर उन्हें पहले मास्टर डेटाबेस में देखता है, फिर संदर्भ डेटाबेस, इस प्रकार अनावश्यक रूप से संसाधनों को बर्बाद कर देता है। और, यदि उपयोगकर्ता द्वारा बनाए गए स्पोक के पास सिस्टम स्पोक के समान नाम है, तो उपयोगकर्ता द्वारा बनाए गए स्पोक को निष्पादित नहीं किया जाएगा।

Sp_ उपसर्ग यह इंगित करता है कि sproc सभी डेटाबेस से सुलभ है, लेकिन यह वर्तमान डेटाबेस के संदर्भ में निष्पादित किया जाना चाहिए।

Here's एक अच्छा स्पष्टीकरण दिया गया है, जिसमें प्रदर्शन हिट का डेमो शामिल है।

एक टिप्पणी में चींटी द्वारा प्रदान किया गया एक और सहायक स्रोत Here's दिया गया है।


TableName_WhatItDoes

  • Comment_GetByID

  • ग्राहकों का विवरण

  • UserPreference_DeleteByUserID

कोई उपसर्ग या मूर्ख हंगेरी बकवास नहीं। बस उस तालिका का नाम जो इसके साथ सबसे करीबी से जुड़ा हुआ है, और यह क्या करता है इसका एक त्वरित विवरण।

उपर्युक्त के लिए एक चेतावनी: मैं व्यक्तिगत रूप से हमेशा अपने सभी स्वत: जेनरेटेड सीआरयूडी को zCRUD_ के साथ उपसर्ग करता हूं ताकि यह सूची के अंत तक हो जहां मुझे इसे देखने की आवश्यकता नहीं है।





naming-conventions