इस लेख में मैं गोलंग चलाने वाले डेटाबेस के साथ काम करने की समस्याओं को संक्षेप में प्रस्तुत करना चाहता हूं। सरल समस्याओं को हल करते समय, ये समस्याएं आमतौर पर दिखाई नहीं देती हैं। जैसे-जैसे प्रोजेक्ट बढ़ता है, वैसे-वैसे समस्या आती है। उनमें से सबसे सामयिक:

• एक डेटाबेस अनुप्रयोग की कनेक्टिविटी कम हो रही है
• डिबग मोड क्वेरी लॉगिंग
• प्रतिकृतियों के साथ काम करें

लेख github.com/adverax/echo/database/sql पैकेज पर आधारित है। इस पैकेज का उपयोग करने का शब्दार्थ मानक डेटाबेस / sql पैकेज के जितना संभव हो उतना करीब है, इसलिए मुझे नहीं लगता कि किसी को भी इसका उपयोग करने में समस्या होगी।

क्षेत्र

एक नियम के रूप में, बड़े सिस्टम सिस्टम के प्रत्येक घटक की जिम्मेदारी के स्पष्ट क्षेत्र के साथ शिथिल रूप से जुड़ने की कोशिश करते हैं। इसलिए, प्रकाशक / ग्राहक डिजाइन पैटर्न व्यापक रूप से प्रचलित हैं। सिस्टम में एक नए उपयोगकर्ता को पंजीकृत करने के एक छोटे से उदाहरण पर विचार करें।

package main import "database/sql" type User struct { Id int64 Name string Language string } type Manager struct { DB *sql.DB OnSignup func(db *sql.DB, user *User) error } func (m *Manager) Signup(user *User) (id int64, err error) { id, err = m.insert(user) if err != nil { return } user.Id = id err = m.OnSignup(m.DB, user) return } func (m *Manager) insert(user *User) (int64, error) { res, err := m.DB.Exec("INSERT ...") if err != nil { return 0, err } id, err := res.LastInsertId() if err != nil { return 0, err } return id, err } func main() { manager := &Manager{ // ... OnSignup: func(db *sql.DB, user *User) error { }, } err := manager.Signup(&User{...}) if err != nil { panic(err) } } 

इस उदाहरण में, हम मुख्य रूप से OnSignup घटना में रुचि रखते हैं। सरल बनाने के लिए, हैंडलर को एकल फ़ंक्शन (वास्तविक जीवन में, सब कुछ अधिक जटिल है) द्वारा दर्शाया जाता है। घटना हस्ताक्षर में, हम पहले पैरामीटर के प्रकार को कठोरता से लिखते हैं, जिसके आमतौर पर दूरगामी परिणाम होते हैं।
मान लीजिए कि अब हम अपने आवेदन की कार्यक्षमता का विस्तार करना चाहते हैं और सफल उपयोगकर्ता पंजीकरण के मामले में अपने व्यक्तिगत खाते में एक संदेश भेजते हैं। आदर्श रूप से, संदेश को उपयोगकर्ता पंजीकरण के समान लेनदेन में रखा जाना चाहिए।

 type Manager struct { DB *sql.DB OnSignup func(tx *sql.Tx, user *User) error } func (m *Manager) Signup(user *User) error { tx, err := m.DB.Begin() if err != nil { return err } defer tx.Rollback() id, err := m.insert(user) if err != nil { return err } user.Id = id err = m.OnSignup(tx, id) if err != nil { return err } return tx.Commit() } func main() { manager := &Manager{ // ... OnSignup: func(db *sql.Tx, user *User) error { }, } err := manager.Signup(&User{...}) if err != nil { panic(err) } } 

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

 import "github.com/adverax/echo/database/sql" type Manager struct { DB sql.DB OnSignup func(scope sql.Scope, user *User) error } func (m *Manager) Signup(user *User) error { tx, err := m.DB.Begin() if err != nil { return err } defer tx.Rollback() id, err := m.insert(user) if err != nil { return err } err = m.OnSignup(tx, id) if err != nil { return err } return tx.Commit() } func main() { manager := &Manager{ // ... OnSignup: func(scope sql.Scope, user *User) error { }, } err := manager.Signup(&User{...}) if err != nil { panic(err) } } 

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

डेटाबेस और संदर्भ

सामान्य व्यवहार में, डेटाबेस का कनेक्शन एक पैरामीटर के रूप में पारित नहीं किया जाता है, जैसा कि ऊपर दिखाया गया है, और प्रत्येक प्रबंधक डेटाबेस से कनेक्शन के लिए एक लिंक रखता है। यह विधि हस्ताक्षरों को सरल बनाता है और कोड पठनीयता में सुधार करता है। हमारे मामले में, इससे बचना असंभव है, क्योंकि लेनदेन के लिए लिंक की आवश्यकता होती है।
संदर्भ में लेन-देन (गुंजाइश) के लिए लिंक डालने के लिए एक सुंदर समाधान है, क्योंकि संदर्भ को एंड-टू-एंड पैरामीटर के रूप में तैनात किया गया है। फिर हम अपने कोड को और सरल कर सकते हैं:

 import ( "context" "github.com/adverax/echo/database/sql" ) type Manager struct { sql.Repository OnSignup func(ctx context.Context, user *User) error } func (m *Manager) Signup(ctx context.Context, user *User) error { return m.Transaction( ctx, func(ctx context.Context, scope sql.Scope) error { id, err := m.insert(user) if err != nil { return err } user.Id = id return m.OnSignup(ctx, user) }, ) } type Messenger struct { sql.Repository } func(messenger *Messenger) onSignupUser(ctx context.Context, user *User) error { _, err := messenger.Scope(ctx).Exec("INSERT ...") return err } func main() { db := ... messenger := &Messenger{ Repository: sql.NewRepository(db), } manager := &Manager{ Repository: sql.NewRepository(db), OnSignup: messenger.onSignup, } err := manager.Signup(&User{...}) if err != nil { panic(err) } } 

यह उदाहरण दिखाता है कि हमने प्रबंधकों के पूर्ण अलगाव को बनाए रखा है, कोड की पठनीयता को बढ़ाया है, और एक ही दायरे में अपने संयुक्त कार्य को प्राप्त किया है।

प्रतिकृति समर्थन

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

 func work() { dsc := &sql.DSC{ Driver: "mysql", DSN: []*sql.DSN{ { Host: "127.0.0.1", Database: "echo", Username: "root", Password: "password", }, { Host: "192.168.44.01", Database: "echo", Username: "root", Password: "password", }, }, } db := dsc.Open(nil) defer db.Close() ... } 

यदि आप डेटाबेस खोलते समय एकल डेटा स्रोत का उपयोग करते हैं, तो यह बिना अतिरिक्त ओवरहेड के सामान्य मोड में खोला जाएगा।

मैट्रिक्स

जैसा कि आप जानते हैं, मैट्रिक्स सस्ते हैं, और लॉग महंगे हैं। इसलिए, डिफ़ॉल्ट मैट्रिक्स के लिए समर्थन जोड़ने का निर्णय लिया गया।

क्वेरी रूपरेखा और लॉगिंग

डीबगिंग के दौरान डेटाबेस क्वेरी लॉग करना बहुत आवश्यक है। हालांकि, मैंने उत्पादन में शून्य ओवरहेड के साथ उच्च-गुणवत्ता वाले लॉगिंग तंत्र को नहीं देखा है। लाइब्रेरी डेटाबेस को लपेटकर आपको इस समस्या को हल करने की अनुमति देती है। डेटाबेस को प्रोफाइल करने के लिए, बस इसके लिए उपयुक्त एक्टिवेटर पास करें:

 func openDatabase(dsc sql.DSC, debug bool) (sql.DB, error){ if debug { return dsc.Open(sql.OpenWithProfiler(nil, "", nil)) } return dsc.Open(nil) } func main() { dsc := ... db, err := openDatabase(dsc, true) if err != nil { panic(err) } defer db.Close() ... } 

निष्कर्ष

अनावश्यक विवरण को छिपाते हुए प्रस्तावित पैकेज आपको डेटाबेस के साथ बातचीत की संभावनाओं का विस्तार करने की अनुमति देता है। यह आपको एप्लिकेशन की बढ़ती जटिलता के बावजूद, इसे शिथिल रूप से जुड़ा हुआ और पारदर्शी छोड़कर, कोड की गुणवत्ता में सुधार करने की अनुमति देता है।