गोलंग डेटाबेस-आधारित क्लाइंट जेनरेटर इंटरफ़ेस

गोलांग डेटाबेस क्लाइंट जनरेटर इंटरफ़ेस पर आधारित है।

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

प्रेरणा

आज पर्याप्त संख्या में पुस्तकालय हैं जो ORMs के रूप में समाधान प्रस्तुत करते हैं, प्रश्नों के निर्माण के लिए सहायक, डेटाबेस स्कीमा के आधार पर सहायकों को उत्पन्न करते हैं।

• https://github.com/jmoiron/sqlx
• https://github.com/go-reform/reform
• https://github.com/jinzhu/gorm
• https://github.com/Masterminds/squirrel
• https://github.com/volatiletech/sqlboiler
• https://github.com/drone/sqlgen
• https://github.com/gocraft/dbr
• https://github.com/go-gorp/gorp
• https://github.com/doug-martin/goqu
• https://github.com/src-d/go-kallax
• https://github.com/go-pg/pg

जब मैंने कई साल पहले गोलांग भाषा में स्विच किया, तो मुझे पहले से ही विभिन्न भाषाओं में डेटाबेस के साथ काम करने का अनुभव था। ORM का उपयोग करना, जैसे कि ActiveRecord, और बिना। प्रेम से घृणा करने के लिए, कोड की कुछ अतिरिक्त पंक्तियों को लिखने में कोई समस्या नहीं है, गोलंग में डेटाबेस के साथ बातचीत करना एक रिपॉजिटरी पैटर्न जैसी चीज के साथ आया। हम डेटाबेस के साथ काम करने के लिए इंटरफ़ेस का वर्णन करते हैं, हम इसे मानक db.Query, row.Scan का उपयोग करके लागू करते हैं। अतिरिक्त रैपर का उपयोग करने के लिए बस समझ में नहीं आया, यह अपारदर्शी था, यह अलर्ट पर रहने के लिए मजबूर करेगा।

SQL भाषा ही पहले से ही आपके प्रोग्राम और रिपॉजिटरी के डेटा के बीच एक अमूर्त है। यह हमेशा मुझे एक डेटा योजना का वर्णन करने की कोशिश करने के लिए, और फिर जटिल प्रश्नों का निर्माण करने के लिए अतार्किक लगा। इस मामले में प्रतिक्रिया संरचना डेटा योजना से अलग है। यह पता चला है कि अनुबंध को डेटा योजना के स्तर पर नहीं, बल्कि अनुरोध और प्रतिक्रिया के स्तर पर वर्णित किया जाना चाहिए। हम वेब विकास में इस दृष्टिकोण का उपयोग करते हैं जब हम एपीआई अनुरोधों और प्रतिक्रियाओं की डेटा संरचनाओं का वर्णन करते हैं। RESTful JSON या gRPC का उपयोग करते हुए सेवा तक पहुँचने पर, हम JSON स्कीमा या प्रोटोबॉफ़ का उपयोग करके अनुरोध और प्रतिक्रिया स्तर पर अनुबंध की घोषणा करते हैं, न कि सेवाओं के अंदर संस्थाओं के डेटा स्कीमा का।

यही है, डेटाबेस के साथ बातचीत एक समान विधि के लिए नीचे आया:

 type User struct { ID int64 Name string } type Store interface { FindUser(id int64) (*User, error) } type Postgres struct { DB *sql.DB } func (pg *Postgres) FindUser(id int64) (*User, error) { var resp User err := pg.DB.QueryRow("SELECT id, name FROM users WHERE id=$1", id).Scan(&resp.ID, &resp.Name) if err != nil { return nil, err } return &resp, nil } func HanlderFindUser(s Store, id int) (*User, error) { // logic of service object user, err := s.FindUser(id) //... } 

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

आवश्यकताएँ

• इंटरफ़ेस के रूप में बातचीत का विवरण।
• इंटरफ़ेस अनुरोधों और प्रतिक्रियाओं के तरीकों और संदेशों द्वारा वर्णित है।
• वैरिएबल और तैयार बयानों के लिए समर्थन।
• नामित तर्क के लिए समर्थन।
• संदेश डेटा संरचना के क्षेत्र में डेटाबेस की प्रतिक्रिया को जोड़ना।
• Atypical डेटा संरचनाओं (सरणी, json) के लिए समर्थन।
• लेन-देन के साथ पारदर्शी काम।
• मिडलवेयर के लिए मूल समर्थन।

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

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

क्वेरी का संकलन करते समय, हम प्रतिस्थापन और चर बंधन का उपयोग करना चाहते हैं। उदाहरण के लिए, PostgreSQL में, आप मूल्य के बजाय $1 लिखते हैं, और क्वेरी के साथ, तर्कों का एक सरणी पास करते हैं। पहले तर्क को परिवर्तित क्वेरी में मान के रूप में उपयोग किया जाएगा। तैयार अभिव्यक्तियों के लिए समर्थन आपको इन समान अभिव्यक्तियों के भंडारण के आयोजन के बारे में चिंता करने की अनुमति नहीं देता है। डेटाबेस / एसक्यूएल लाइब्रेरी तैयार अभिव्यक्तियों का समर्थन करने के लिए एक शक्तिशाली उपकरण प्रदान करता है, यह स्वयं कनेक्शन पूल, बंद कनेक्शन का ख्याल रखता है। लेकिन उपयोगकर्ता की ओर से, लेनदेन में तैयार अभिव्यक्ति का पुन: उपयोग करने के लिए एक अतिरिक्त कार्रवाई आवश्यक है।

डेटाबेस, जैसे PostgreSQL और MySQL, प्रतिस्थापन और चर बाइंडिंग का उपयोग करने के लिए अलग-अलग सिंटैक्स का उपयोग करते हैं। PostgreSQL $1 , $2 , ... MySQL का उपयोग करता है ? मूल्य के स्थान की परवाह किए बिना। डेटाबेस / एसक्यूएल लाइब्रेरी ने नामित तर्कों के लिए एक सार्वभौमिक प्रारूप का प्रस्ताव दिया https://golang.org/pkg/database/sql/#NamedArg । उपयोग उदाहरण:

 db.ExecContext(ctx, `DELETE FROM orders WHERE created_at < @end`, sql.Named("end", endTime)) 

PostgreSQL या MySQL समाधानों की तुलना में इस प्रारूप के लिए समर्थन बेहतर है।

सॉफ़्टवेयर ड्राइवर को संसाधित करने वाले डेटाबेस से प्रतिक्रिया को निम्नानुसार सशर्त रूप से दर्शाया जा सकता है:

 dev > SELECT * FROM rubrics; id | created_at | title | url ----+-------------------------+-------+------------ 1 | 2012-03-13 11:17:23.609 | Tech | technology 2 | 2015-07-21 18:05:43.412 | Style | fashion (2 rows) 

इंटरफ़ेस स्तर पर उपयोगकर्ता के दृष्टिकोण से, प्रपत्र की संरचनाओं की एक सरणी के रूप में आउटपुट पैरामीटर का वर्णन करना सुविधाजनक है:

 type GetRubricsResp struct { ID int CreatedAt time.Time Title string URL string } 

अगला, resp.ID पर id वैल्यू प्रोजेक्ट करें। सामान्य तौर पर, यह कार्यक्षमता सबसे अधिक जरूरतों को कवर करती है।

आंतरिक डेटा संरचनाओं के माध्यम से संदेशों की घोषणा करते समय, सवाल उठता है कि गैर-मानक डेटा प्रकारों का समर्थन कैसे करें। उदाहरण के लिए, एक सरणी। यदि आप PostgreSQL के साथ काम करते समय github.com/lib/pq ड्राइवर का उपयोग करते हैं, तो आप क्वेरी तर्क या प्रतिक्रिया को स्कैन करते समय pq.Array(&x) जैसे सहायक कार्यों का उपयोग कर सकते हैं। प्रलेखन से उदाहरण:

 db.Query(`SELECT * FROM t WHERE id = ANY($1)`, pq.Array([]int{235, 401})) var x []sql.NullInt64 db.QueryRow('SELECT ARRAY[235, 401]').Scan(pq.Array(&x)) 

तदनुसार, डेटा संरचनाओं को तैयार करने के तरीके होने चाहिए।

इंटरफ़ेस के किसी भी तरीके को निष्पादित करते समय, डेटाबेस कनेक्शन का उपयोग *sql.DB के रूप में किया जा सकता है। यदि आपको किसी एकल लेन-देन के भीतर कई तरीकों को निष्पादित करने की आवश्यकता है, तो मैं एक लेनदेन के बाहर काम करने के लिए एक समान दृष्टिकोण के साथ पारदर्शी कार्यक्षमता का उपयोग करना चाहता हूं, अतिरिक्त तर्क पारित नहीं करता हूं।

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

अधिकांश भाग के लिए, डेटाबेस परिदृश्यों के व्यवस्थितकरण के रूप में आवश्यकताओं को तैयार किया गया था।

समाधान: गो-गैजेट / सैल

बॉयलरप्लेट कोड से निपटने का एक तरीका इसे उत्पन्न करना है। सौभाग्य से, गोलंग के पास इस https://blog.golang.org/generate के उपकरण और उदाहरण हैं। GoMock के https://github.com/golang/mock दृष्टिकोण को पीढ़ी के लिए एक वास्तु समाधान के रूप में लिया गया था, जहां प्रतिबिंब का उपयोग करके इंटरफ़ेस विश्लेषण किया जाता है। इस दृष्टिकोण के आधार पर, आवश्यकताओं के अनुसार, सैल्जेन उपयोगिता और सैल लाइब्रेरी को लिखा गया था, जो इंटरफ़ेस कार्यान्वयन कोड उत्पन्न करते हैं और सहायक कार्यों का एक सेट प्रदान करते हैं।

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

 package repo import "context" //go:generate salgen -destination=./postgres_client.go -package=dev/taxi/repo dev/taxi/repo Postgres type Postgres interface { CreateDriver(ctx context.Context, r *CreateDriverReq) error } type CreateDriverReq struct { taxi.Driver } func (r *CreateDriverReq) Query() string { return `INSERT INTO drivers(id, name) VALUES(@id, @name)` } 

इंटरफ़ेस

यह सब इंटरफ़ेस और go generate यूटिलिटी के लिए एक विशेष कमांड की घोषणा के साथ शुरू होता है:

 //go:generate salgen -destination=./client.go -package=github.com/go-gad/sal/examples/profile/storage github.com/go-gad/sal/examples/profile/storage Store type Store interface { ... 

यहां यह वर्णित है कि हमारे Store इंटरफ़ेस के लिए, कंसोल उपयोगिता salgen को पैकेज से बुलाया जाएगा, जिसमें दो विकल्प और दो तर्क होंगे। पहला विकल्प -destination निर्धारित करता है कि किस कोड में जनरेट कोड लिखा जाएगा। दूसरा विकल्प- -package उत्पन्न कार्यान्वयन के लिए पुस्तकालय के पूर्ण पथ (आयात पथ) को परिभाषित करता है। निम्नलिखित दो तर्क हैं। पहले पूर्ण पैकेज पथ ( github.com/go-gad/sal/examples/profile/storage ) का वर्णन करता है जहाँ इंटरफ़ेस स्थित है, दूसरा इंटरफ़ेस के नाम को इंगित करता है। ध्यान दें कि go generate लिए कमांड कहीं भी स्थित हो सकती है, जरूरी नहीं कि लक्ष्य इंटरफेस के बगल में हो।

go generate कमांड को निष्पादित करने के बाद, हमें एक कंस्ट्रक्टर मिलता है जिसका नाम इंटरफ़ेस नाम में New उपसर्ग जोड़कर बनाया गया है। sal.QueryHandler इंटरफ़ेस के अनुरूप एक आवश्यक पैरामीटर लेता है:

 type QueryHandler interface { QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) } 

यह इंटरफ़ेस *sql.DB ऑब्जेक्ट से मेल *sql.DB है।

 connStr := "user=pqgotest dbname=pqgotest sslmode=verify-full" db, err := sql.Open("postgres", connStr) client := storage.NewStore(db) 

तरीके

इंटरफ़ेस विधियाँ उपलब्ध डेटाबेस क्वेरी के सेट को निर्धारित करती हैं।

 type Store interface { CreateAuthor(ctx context.Context, req CreateAuthorReq) (CreateAuthorResp, error) GetAuthors(ctx context.Context, req GetAuthorsReq) ([]*GetAuthorsResp, error) UpdateAuthor(ctx context.Context, req *UpdateAuthorReq) error } 

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

पहला तर्क हमेशा context.Context है। context.Context वस्तु। डेटाबेस और टूलकिट को लागू करते समय इस संदर्भ को पारित किया जाएगा। दूसरा तर्क बेस टाइप struct (या पॉइंटर टू struct ) के साथ एक पैरामीटर की अपेक्षा करता है। पैरामीटर को निम्न इंटरफ़ेस को पूरा करना चाहिए:

 type Queryer interface { Query() string } 

डेटाबेस क्वेरी निष्पादित करने से पहले Query() पद्धति को कॉल किया जाएगा। परिणामी स्ट्रिंग को डेटाबेस-विशिष्ट प्रारूप में परिवर्तित किया जाएगा। यही है, PostgreSQL के लिए, @end को $1 बदल दिया जाएगा, और मान &req.End को तर्कों की सरणी में पास कर दिया जाएगा

आउटपुट मापदंडों के आधार पर, यह निर्धारित किया जाता है कि कौन से तरीके (क्वेरी / एक्ज़ेक) कहलाएंगे:

• यदि पहला पैरामीटर बेस टाइप struct (या struct लिए एक पॉइंटर) का है, तो QueryContext मेथड कहा जाएगा। यदि डेटाबेस से प्रतिक्रिया में एक भी पंक्ति नहीं होती है, तो sql.ErrNoRows त्रुटि sql.ErrNoRows जाएगी। यही है, व्यवहार db.QueryRow समान है।
• यदि पहला पैरामीटर आधार प्रकार के slice , तो QueryContext विधि को बुलाया जाएगा। यदि डेटाबेस से प्रतिक्रिया में पंक्तियाँ नहीं होती हैं, तो एक खाली सूची वापस आ जाएगी। सूची आइटम का आधार प्रकार होना चाहिए (या किसी struct लिए सूचक)।
• यदि आउटपुट पैरामीटर error प्रकार के साथ एक है, तो ExecContext विधि को बुलाया जाएगा।

तैयार बयान

उत्पन्न कोड तैयार भावों का समर्थन करता है। तैयार अभिव्यक्तियाँ कैश की जाती हैं। अभिव्यक्ति की पहली तैयारी के बाद, यह कैश्ड है। डेटाबेस / एसक्यूएल लाइब्रेरी स्वयं यह सुनिश्चित करती है कि तैयार किए गए भावों को पारदर्शी डेटाबेस कनेक्शन पर पारदर्शी रूप से लागू किया जाता है, जिसमें बंद कनेक्शन प्रसंस्करण भी शामिल है। बदले में, go-gad/sal लाइब्रेरी लेन-देन के संदर्भ में तैयार कथन का पुन: उपयोग करने का ख्याल रखता है। जब तैयार अभिव्यक्ति निष्पादित होती है, तो तर्क को चर बंधन का उपयोग करके पारित किया जाता है, डेवलपर के लिए पारदर्शी।

go-gad/sal लाइब्रेरी साइड पर नामित तर्कों का समर्थन करने के लिए, अनुरोध डेटाबेस के लिए उपयुक्त दृश्य में परिवर्तित हो जाता है। अब PostgreSQL के लिए रूपांतरण समर्थन है। क्वेरी ऑब्जेक्ट का फ़ील्ड नाम नामित तर्कों में स्थानापन्न करने के लिए उपयोग किया जाता है। ऑब्जेक्ट फ़ील्ड नाम के बजाय एक अलग नाम निर्दिष्ट करने के लिए, आपको संरचना फ़ील्ड के लिए sql टैग का उपयोग करना होगा। एक उदाहरण पर विचार करें:

 type DeleteOrdersRequest struct { UserID int64 `sql:"user_id"` CreateAt time.Time `sql:"created_at"` } func (r * DeleteOrdersRequest) Query() string { return `DELETE FROM orders WHERE user_id=@user_id AND created_at<@end` } 

क्वेरी स्ट्रिंग को परिवर्तित किया जाएगा, और पत्राचार तालिका और चर बंधन का उपयोग करते हुए, एक सूची क्वेरी निष्पादन तर्कों को पास की जाएगी:

 // generated code: db.Query("DELETE FROM orders WHERE user_id=$1 AND created_at<$2", &req.UserID, &req.CreatedAt) 

अनुरोधों के तर्कों और प्रतिक्रिया संदेशों के लिए मानचित्र की संरचना

go-gad/sal लाइब्रेरी डेटाबेस संरचनाओं की प्रतिक्रिया लाइनों को प्रतिक्रिया संरचनाओं के साथ, संरचना क्षेत्रों के साथ टेबल कॉलम का ध्यान रखती है:

 type GetRubricsReq struct {} func (r GetRubricReq) Query() string { return `SELECT * FROM rubrics` } type Rubric struct { ID int64 `sql:"id"` CreateAt time.Time `sql:"created_at"` Title string `sql:"title"` } type GetRubricsResp []*Rubric type Store interface { GetRubrics(ctx context.Context, req GetRubricsReq) (GetRubricsResp, error) } 

और अगर डेटाबेस प्रतिक्रिया है:

 dev > SELECT * FROM rubrics; id | created_at | title ----+-------------------------+------- 1 | 2012-03-13 11:17:23.609 | Tech 2 | 2015-07-21 18:05:43.412 | Style (2 rows) 

फिर GetRubricsResp सूची हमारे पास वापस आ जाएगी, जिनमें से तत्व रूब्रिक को इंगित किए जाएंगे, जहां फ़ील्ड उन स्तंभों से मानों से भरे हुए हैं जो टैग नामों के अनुरूप हैं।

यदि डेटाबेस प्रतिक्रिया में समान नाम वाले कॉलम होते हैं, तो संबंधित संरचना फ़ील्ड को घोषणा क्रम में चुना जाएगा।

 dev > select * from rubrics, subrubrics; id | title | id | title ----+-------+----+---------- 1 | Tech | 3 | Politics 

 type Rubric struct { ID int64 `sql:"id"` Title string `sql:"title"` } type Subrubric struct { ID int64 `sql:"id"` Title string `sql:"title"` } type GetCategoryResp struct { Rubric Subrubric } 

गैर-मानक डेटा प्रकार

database/sql पैकेज बुनियादी डेटा प्रकारों (तार, संख्या) के लिए समर्थन प्रदान करता है। अनुरोध या प्रतिक्रिया में डेटा प्रकारों जैसे सरणी या driver.Valuer को driver.Valuer करने के लिए, driver.Valuer का समर्थन करना आवश्यक है। driver.Valuer और sql.Scanner । विभिन्न चालक कार्यान्वयन में विशेष सहायक कार्य होते हैं। उदाहरण के लिए lib/pq.Array ( https://godoc.org/github.com/lib/pq#Array ):

 func Array(a interface{}) interface { driver.Valuer sql.Scanner } 

डिफ़ॉल्ट रूप से, दृश्य संरचना क्षेत्रों के लिए go-gad/sql लाइब्रेरी

 type DeleteAuthrosReq struct { Tags []int64 `sql:"tags"` } 

मूल्य &req.Tags उपयोग करेगा। यदि संरचना sal.ProcessRower को sal.ProcessRower है।

 type ProcessRower interface { ProcessRow(rowMap RowMap) } 

तब इस्तेमाल किया गया मूल्य समायोजित किया जा सकता है

 func (r *DeleteAuthorsReq) ProcessRow(rowMap sal.RowMap) { rowMap.Set("tags", pq.Array(r.Tags)) } func (r *DeleteAuthorsReq) Query() string { return `DELETE FROM authors WHERE tags=ANY(@tags::UUID[])` } 

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

लेन-देन

लेनदेन का समर्थन करने के लिए, इंटरफ़ेस (स्टोर) का विस्तार निम्नलिखित तरीकों से किया जाना चाहिए:

 type Store interface { BeginTx(ctx context.Context, opts *sql.TxOptions) (Store, error) sal.Txer ... 

विधियों का कार्यान्वयन उत्पन्न होगा। BeginTx विधि वर्तमान sal.QueryHandler ऑब्जेक्ट से कनेक्शन का उपयोग करती है और लेनदेन db.BeginTx(...) खोलता है; Store इंटरफ़ेस का एक नया कार्यान्वयन ऑब्जेक्ट देता है, लेकिन प्राप्त *sql.Tx रूप में प्राप्त *sql.Tx ऑब्जेक्ट का उपयोग करता है

middleware

हुक एम्बेडिंग उपकरण के लिए प्रदान किए जाते हैं।

 type BeforeQueryFunc func(ctx context.Context, query string, req interface{}) (context.Context, FinalizerFunc) type FinalizerFunc func(ctx context.Context, err error) 

इससे पहले कि BeforeQueryFunc हुक को db.PrepareContext या db.Query पहले db.Query । यही है, प्रोग्राम के शुरू में, जब तैयार अभिव्यक्ति कैश खाली होती है, जब store.GetAuthors कॉल किया जाता है, तो BeforeQueryFunc हुक को दो बार कहा जाएगा। इससे पहले कि आप हमारे केस store.GetAuthors में बाहर store.GetAuthors , इससे पहले कहा जाता है।

हुक के निष्पादन के समय, सेवा को निम्न मानों के साथ सेवा कुंजियों से भरा जाता है:

• ctx.Value(sal.ContextKeyTxOpened) बूलियन मान निर्धारित करता है कि विधि लेनदेन के संदर्भ में कहा जाता है या नहीं।
• ctx.Value(sal.ContextKeyOperationType) , ऑपरेशन के प्रकार का स्ट्रिंग मान, "QueryRow" , "Query" , "Exec" , "Commit" , आदि।
• ctx.Value(sal.ContextKeyMethodName) इंटरफ़ेस विधि का स्ट्रिंग मान, जैसे "GetAuthors" ।

तर्कों के रूप में, BeforeQueryFunc हुक क्वेरी के sql स्ट्रिंग और उपयोगकर्ता क्वेरी विधि के req तर्क को स्वीकार करता है। FinalizerFunc हुक एक तर्क के रूप में एक err चर लेता है।

 beforeHook := func(ctx context.Context, query string, req interface{}) (context.Context, sal.FinalizerFunc) { start := time.Now() return ctx, func(ctx context.Context, err error) { log.Printf( "%q > Opeartion %q: %q with req %#v took [%v] inTx[%v] Error: %+v", ctx.Value(sal.ContextKeyMethodName), ctx.Value(sal.ContextKeyOperationType), query, req, time.Since(start), ctx.Value(sal.ContextKeyTxOpened), err, ) } } client := NewStore(db, sal.BeforeQuery(beforeHook)) 

आउटपुट उदाहरण:

 "CreateAuthor" > Opeartion "Prepare": "INSERT INTO authors (Name, Desc, CreatedAt) VALUES($1, $2, now()) RETURNING ID, CreatedAt" with req <nil> took [50.819µs] inTx[false] Error: <nil> "CreateAuthor" > Opeartion "QueryRow": "INSERT INTO authors (Name, Desc, CreatedAt) VALUES(@Name, @Desc, now()) RETURNING ID, CreatedAt" with req bookstore.CreateAuthorReq{BaseAuthor:bookstore.BaseAuthor{Name:"foo", Desc:"Bar"}} took [150.994µs] inTx[false] Error: <nil> 

आगे क्या है

• MySQL के लिए बाध्यकारी चर और तैयार अभिव्यक्तियों के लिए समर्थन।
• RowAppender हुक प्रतिक्रिया को समायोजित करने के लिए।
• Exec.Result का मान Exec.Result ।