MySQL अतुल्यकालिक एपीआई अनुरोध (libmysqlclient)

यह पता चला है कि अब मैं MySQL कनेक्शन के लिए एक अनुसूचक पर काम कर रहा हूं। और यहाँ हाल ही में मुझे प्रलेखन / ब्लॉग आदि में तल्लीन होना पड़ा। और इसलिए मैंने API और libmysqlclient लाइब्रेरी का उपयोग करके C ++ में MySQL सर्वर पर अतुल्यकालिक प्रश्नों को लागू करने का तरीका समुदाय के साथ साझा करने का निर्णय लिया।



MySQL API का उपयोग करके प्रोग्रामिंग शुरू करने के लिए, हमें mysql.h हैडर फ़ाइल की आवश्यकता है।
और libmysqlclient लाइब्रेरी। डीब-जैसे OS के लिए, यह सब इस तरह से रखा जा सकता है:

sudo apt-get install libmysqlclient-dev libmysqlclient 

हम संकलक को निम्नलिखित संकेत देते हैं:
-L / path / to / mysqliclientlib / -lmysqlclient

यदि आप Qt क्रिएटर में कोड लिखते हैं, तो आप प्रोजेक्ट फ़ाइल में निम्नलिखित जोड़ सकते हैं (आपके पास एक अलग रास्ता हो सकता है):
LIBS + = -L / usr / lib / mysql -lmysqlclient

C ++ में MySQL के साथ काम करने के लिए लगभग सब कुछ हमारे लिए तैयार है।
हम परिभाषित करते हैं: अतुल्यकालिक प्रश्न - थ्रेड का उपयोग किए बिना डेटाबेस के कई समानांतर प्रश्न। Mysql_real_query फ़ंक्शन का उपयोग करते हुए, यह प्राप्त नहीं किया जा सकता है, अर्थात। कार्यक्रम सर्वर से परिणाम (प्रतिक्रिया) की प्रतीक्षा करेगा।

अन्य बातों के अलावा, मैं घटनाओं को पकड़ने के लिए libevent पुस्तकालय का उपयोग करता हूं। आप इसे इस तरह डाल सकते हैं:

 sudo apt-get install libevent-dev libevent 

हम संकलक को बताते हैं:
LIBS + = -L / usr / lib / mysql -lmysqlclient -L / usr / lib / -वेंट
हैडर फ़ाइल:
# जारी करें <event.h>

सब कुछ, सब कुछ तैयार है। नीचे उतर रहा है। इसलिए हम एक वर्ग लिखते हैं जो अनुरोधों को अतुल्यकालिक रूप से भेजेगा। इस वर्ग में मेरे लिए तरीके भी हैं - मैं केवल उन लोगों पर ध्यान केंद्रित करूँगा जो विषय से संबंधित हैं।

 class CBalanceMySQL { private: //    //    unsigned int thread_count; //    std::vector<MYSQL*> v; //  std::vector<event*> events; //  std::vector<std::string> queries; struct event_base *evbase; //   ,      //     pFunc p_func; //      void run(); public: // constructor CBalanceMySQL(); // destructor ~CBalanceMySQL(); //      //     void setThreadCount(int); //    bool ConnectAllThreads(); //        bool setSuccessFunc(void(*)(int, short, void*)); }; 

क्लास कंस्ट्रक्टर (या कहीं और) में हम ईवेंट बेस को इनिशियलाइज़ करते हैं:

 this->evbase = event_base_new(); 

अगला, हमें सर्वर के साथ कनेक्शन स्थापित करने और उन्हें "याद रखने" की आवश्यकता होगी। हम दिए गए संख्याओं के लिए एक चक्र में चलते हैं और वेक्टर v में कनेक्शन को बचाते हैं।

 bool CBalanceMySQL::ConnectAllThreads() { for (uint i = 0; i < this->thread_count; i++) { MYSQL *m; m = mysql_init(NULL); if (!mysql_real_connect(m, this->host, this->user, this->password, NULL, this->port, NULL, 0)) { std::cout << mysql_error(m); return 0; } else { this->v.push_back(m); } } return 1; } 

इन कनेक्शनों के लिए हमें जिन अनुरोधों की आवश्यकता है, उन्हें पूरा करना बाकी है:

 void CBalanceMySQL::run() { for (uint i = 0; i < this->v.size(); i++) { //  struct event *ev; //     std::string q = this->queries.at(i); //    MYSQL *m = this->v.at(i); //   mysql_send_query(m, q.c_str() , strlen(q.c_str())); ev = new event; //   //   -      p_func event_set(ev, m->net.fd, EV_READ, this->p_func, m); event_base_set(this->evbase, ev); event_add(ev, NULL); events.push_back(ev); } //         while (0 == event_base_loop(this->evbase, 0)); } 

यह लगभग सभी है। यह खुद के लिए साफ रहता है:

 for (uint i = 0; i < v.size(); i++) { mysql_close(this->v.at(i)); } for (uint i = 0; i < events.size(); i++) { delete(this->events.at(i)); } event_base_free(this->evbase); 

और अंतिम अनुरोध के परिणाम को संसाधित करने का कार्य है। इसका रूप है:

 static void read_result(int fd, short event, void *_userdata) { MYSQL *m = (MYSQL*)_userdata; if (0 == mysql_read_query_result(m)) { MYSQL_RES *res = mysql_store_result(m); MYSQL_ROW row = mysql_fetch_row(res); //     SELECT COUNT(*) FROM information_schema.processlist,      cout << "cnt for net.fd = " << fd << " is " << row[0] << endl; mysql_free_result(res); } } 

वह सब है। मुझे उम्मीद है कि कोई काम आएगा।
ps ज्यादा लात नहीं मारता - C ++ में गुरु नहीं।