🏞️ 🈂️ 👨‍👩‍👧‍👦 Multithreaded Qt अनुप्रयोगों में DBMS कनेक्शन का उपयोग करना 🖐🏿 🕺🏽 🥞

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

समस्याओं

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

निर्णय

नतीजतन, हमें 3 कक्षाएं मिलीं:

कनेक्शन - डेटाबेस के साथ काम करने के लिए जिम्मेदार एक आवरण वर्ग: कनेक्शन, निष्पादन और क्वेरी परिणामों के प्रसंस्करण।
ConnectionManager - अपने आप में एक एकलिंग कनेक्शन दफनाने और कनेक्शन जारी करने और जारी करने के लिए जिम्मेदार है।
ManagedConnection - एक कनेक्शन को पकड़ने और जारी करने के लिए एक वर्ग आवरण।

संबंध

वर्ग निर्माता में, QSqlDatabase _conn सदस्य को आरंभीकृत किया जाता है और (खुला) कनेक्शन कहा जाता है:

Connection::Connection(const QString& ident, const QString& driver, const QString& dbHost, const QString& dbName, const QString& dbUser, const QString& dbPassword, int dbPort) : _threadId(0), _countRef(0), _countBegins(0), _retryCount(0),_invalid(false) { _conn = QSqlDatabase::addDatabase(driver, ident); _conn.setHostName(dbHost); _conn.setDatabaseName(dbName); _conn.setUserName(dbUser); _conn.setPassword(dbPassword); _conn.setPort(dbPort), open(); }

डेटाबेस के साथ काम करने के लिए मूल प्रोटोटाइप विधि

  void exec(QSqlQuery& sql); void exec(const char* sql); void exec(const QString& sql); /** *   ,         */ template <typename T> void fetchCol(QSqlQuery& sql,QList<T>& result)... template <typename T> QList<T> fetchCol(QSqlQuery& sql) ... template <typename T> QList<T> fetchCol(const char* sql) ... template <typename T> QList<T> fetchCol(const QString& sql) ... /* *         */ template <typename T> T fetchOne(QSqlQuery& sql, bool* ok = 0) ... template <typename T> T fetchOne(const QString& sql, bool* ok = 0) ... template <typename T> T fetchOne(const char* sql, bool* ok = 0) ... /* *     */ void fetchRow(QSqlQuery& sql,QVariantMap& res); QVariantMap fetchRow(const QString& sql); QVariantMap fetchRow(const char* sql); QVariantMap fetchRow(QSqlQuery& sql); /** *     */ void query(QSqlQuery& sql,QList<QVariant>& result); QList<QVariant> query(const char* sql); QList<QVariant> query(QSqlQuery& sql); QList<QVariant> query(const QString& sql); /*  query */ void fetchAll(QSqlQuery& sql,QList<QVariant>& result); QList<QVariant> fetchAll(const char* sql); QList<QVariant> fetchAll(QSqlQuery& sql); QList<QVariant> fetchAll(const QString& sql);

क्योंकि क्यूटी में, डेटाबेस के साथ काम करने के लिए, QSqlQuery का उपयोग किया जाता है, जो QSqlDatabase पर निर्भर करता है, फिर क्वेरी बनाने के लिए विधियों का उपयोग करना सख्ती से आवश्यक है:

  QSqlQuery createQuery() const { return QSqlQuery(_conn);} QSqlQuery createQuery(const QString& sql) { return QSqlQuery(sql, _conn); }

ManagedConnection

वर्ग कनेक्शन और ConnetcionManager को बांधता है।
ऑब्जेक्ट बनाते समय, पहचानकर्ता (उदाहरण के लिए, db1confin) द्वारा ConnetcionManager से एक कनेक्शन का अनुरोध करने का प्रयास किया जाता है। कैप्चर करने के बाद, एक कनेक्शन पॉइंटर मेंबर को इनिशियलाइज़ किया जाता है। सुविधा के लिए, ऑपरेटर को फिर से परिभाषित किया जाता है -> ताकि कनेक्शन विधियों को बुलाया जाए।
आमतौर पर, एक एप्लिकेशन को केवल एक डेटाबेस से कनेक्शन की आवश्यकता होती है। इसलिए, यह पहचानकर्ता को "डिफ़ॉल्ट" देने के लिए प्रथागत था।
टाइपडिफ प्रकार ManagedConnection DConn आपको एक कनेक्शन प्राप्त करने की अनुमति देगा। उदाहरण के लिए

 DB::DConn conn; // DB::ManagedConnection conn("default'); //   DB::ManagedConnection c1("db1conn); DB::ManagedConnection c2("db2conn);

उदाहरण के लिए छद्म कोड पर कॉल स्टैक लें। ऑर्डर डेटाबेस में अपने डेटा को संग्रहीत करता है और अपने सदस्य आइटम के भंडारण को कॉल करता है (आईडील में बहुत सारे हैं)। आइटम डेटाबेस में अपने डेटा को बचाता है और इसके डेटा सदस्य को सहेजने का कारण बनता है। डेटा डेटाबेस में अपना डेटा संग्रहीत करता है। परिणामस्वरूप, 3 स्तरों पर घोंसला बनाना:

 Order : save(){ DB::DBConn conn; // . countRef = 1 conn->query('INSERT INTO order...'); item->save(); Item:save() { DB::DBConn conn;// . countRef = 2 conn->query('INSERT INTO item...'); data->save(); Data:save() { DB::DBConn conn;// . countRef = 3 conn->query('INSERT INTO data...'); // ,   ~ManagedConnection countRef = 2 } // ,   ~ManagedConnection countRef = 1 } // ,   ~ManagedConnection countRef = 0 } } }

ConnectionManager

कनेक्शन के लिए सेटिंग्स को स्टोर करें: होस्ट, पोर्ट, आधार का प्रकार, आदि।
उदाहरण के लिए, एक आवेदन के लिए, आपके पास db1 डेटाबेस प्रकार MySQL और db2 प्रकार PostgresSQL के साथ एक कनेक्शन होना चाहिए। कॉन्फ़िगरेशन फ़ाइल में सेटिंग इस तरह दिखाई देगी:

 [database] size = 2 ; 1\ident=db1conn ; ,    MySQL 1\driver=QMYSQL ;  1\host=localhost ;   1\name=db1 ;  1\user=db1_user ; 1\password=lol ; 1\port=3306 ; -         1\max_count = 30 2\ident=db2conn 2\driver=QPSQL 2\host=localhost 2\name=test 2\user=postgres 2\password= 2\port=5432 2\max_count = 30

जब अनुप्रयोग शुरू होता है, तो कॉन्फ़िगरेशन को पढ़ा जाता है और QVariantMap में बदल दिया जाता है।
आवेदन प्रारंभिक उदाहरण

 Application::Application(int& argc, char** argv): QCoreApplication(argc, argv) { ... QVariantMap stgs = settings(); DB::ConnectionManager::init(stgs); ... }

ConnectionManager के स्थिर सदस्य को विन्यास से स्थिर किया जाता है (static QMap <QString, ConnectionManager *> _instances;)
मानचित्र में कुंजी के रूप में पहचान विन्यास से पहचानकर्ता का उपयोग किया जाएगा

 void ConnectionManager::init(const QVariantMap& settings) { const int size = settings.value("database/size").toInt(); for (int i = 1; i <= size; ++i) { const QString ident = settings.value(QString("database/%1/ident").arg(i), "default").toString(); ConnectionManager* inst = new ConnectionManager( ident, settings.value(QString("database/%1/driver").arg(i)).toString(), ... ); _instances[ident] = inst; Log::info(QString("ConnectionManager::init: [%1] [%2@%3:%4] ").arg(inst->_driver).arg(inst->_dbUser).arg(inst->_dbHost).arg(inst->_dbPort)); } }

मानचित्र में कुंजी के रूप में पहचान विन्यास से पहचानकर्ता का उपयोग किया जाएगा
GetConnection class का मुख्य तरीका (कोड टिप्पणियों में समझाया गया है):

 Connection* ConnectionManager::getConnection() { Connection* conn = 0; int count = 0; while(count++ < MAX_RETRY_GET_CONN_COUNT) { pthread_t thread_id = pthread_self(); //  ,           { QMutexLocker mlocker(&_mutex); for (int i = 0; i < _pool.size(); ++i) { conn = _pool.at(i); //    if (conn && conn->threadID() == thread_id && conn->isValid()) { //         conn->lock(); //Log::debug(QString("ConnectionManager::getConnection          thread [%1])").arg(conn->name())); return conn; } } } //       ,       { QMutexLocker mlocker(&_mutex); for (int i = 0; i < _pool.size(); ++i) { conn = _pool.at(i); if (conn && !conn->isLocked() && conn->isValid() ) { //Log::debug(QString("ConnectionManager::getConnection    [%1])").arg(conn->name())); //   conn->lock(); return conn; } } } //       { QMutexLocker mlocker(&_mutex); if(_currentCount < _maxCount) { //      //    //try { conn = new Connection( QString("%1_%2").arg(_ident).arg(_currentCount), _driver, _dbHost, _dbName, _dbUser, _dbPassword,_dbPort ); _currentCount++; conn->lock(); _pool.append(conn); return conn; /*} catch(exc::Message& ex) { delete conn; throw ex; }*/ } else { //   //Log::warn("  - [%d]    DB  [%d]",_maxCount,count); /*for (int i = 0; i < _pool.size(); ++i) { conn = _pool.at(i); if (!conn->isValid() && !conn->isLocked() ) { removeConnection(conn); break; } }*/ } } // , //     sleep(2); } Log::crit(" %d       ",MAX_RETRY_GET_CONN_COUNT); { QMutexLocker mlocker(&_mutex); for (int i = 0; i < _pool.size(); ++i) { conn = _pool.at(i); if (!conn->isValid() && !conn->isLocked()) { removeConnection(conn); break; } } } throw exc::Message("     "); //return 0; }

काम का तर्क

कनेक्शन बनाने के लिए कौन सी सेटिंग्स है, और उनकी अधिकतम संख्या क्या है, यह जानने के लिए कॉन्टेक्स्टमैनेजर को कॉन्फिगर किया जाता है।
जब आप DB :: ManagedConnection का एक उदाहरण बनाते हैं, तो आप ConnetctionManager का उपयोग करते हैं और ConnetctionManager से एक संकेतक प्राप्त करने का प्रयास करते हैं :: getConnetction।
ConnetctionManager में :: कई प्रयासों का उपयोग कर getConnetction होता है:

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

DB :: ManagedConnection वर्ग की एक आवृत्ति को हटाने के बाद, कनेक्शन RefCount कम हो जाता है। यदि refCount == 0, कनेक्शन अन्य थ्रेड्स को पकड़ने के लिए उपलब्ध हो जाता है।

उदाहरण का उपयोग करें

 QList<QVariant> Bank::banksByAccountNumber(const QString& accountNumber) { QList<QVariant> res; DB::ManagedConnection conn; foreach(const QVariant& row, conn->fetchAll( "SELECT `real` as state ,namen as name,namep as full_name," "newnum as bik,ksnp as korr_acc,okpo as okpo,nnp as city," "ind as zip, adr as address,regn as regnum, telef as phones FROM `bankdinfo` WHERE `real` = '' ORDER BY RAND()" )) { if(isBelongToBank((row.toMap()["bik"]).toString(),accountNumber)) { res.append(row); } } Log::debug("Banks found %d",res.size()); return res; }

गीथूब पर सूत्र
युपीडी
लोड के चरम पर, कनेक्शन की अधिकतम संख्या (कॉन्फ़िगरेशन में निर्दिष्ट) बनाई जाती है, लेकिन लोड ड्रॉप होने के बाद, कनेक्शन बंद नहीं होते हैं और संसाधन नहीं लेते हैं। यह पता चला है कि एक धागे को चलाने के लिए आवश्यक है जो कनेक्शनों को बंद कर देगा, उनकी इष्टतम संख्या को छोड़ देगा, लेकिन यह स्पष्ट नहीं है कि यह संख्या इस समय क्या मापदंड निर्धारित करेगी।
ऑपरेशन के दौरान, हमें इस तथ्य का सामना करना पड़ा कि MySQL दिन में एक बार कनेक्शन काटता है, और ऐसा होता है कि DBMS को ओवरलोड करने की आवश्यकता होती है। एप्लीकेशन फॉल्ट टॉलरेंस के लिए, मुझे कनेक्शन में बहुत लचीला कोड नहीं जोड़ना पड़ा:

 bool Connection::tryRetry(const QSqlError& err) { //    bool needRecon = false; QRegExp mrx("MySQL server has gone away"); if (err.type() == QSqlError::NoError && qstrcmp(_conn.driver()->handle().typeName(), "PGconn*") == 0) { needRecon = true; } else if ( /*(qstrcmp(_conn.driver()->handle().typeName(), "MYSQL*") == 0)*/ err.text().contains(mrx)) { needRecon = true; } bool ok = false; if (needRecon) { Log::err( "     - GONE AWAY.   ..."); bool lol = true; while(lol) { if (_retryCount >= MAX_RETRY_COUNT) { _retryCount = 0; _invalid = true; Log::crit( "       ."); throw exc::Message("     "); } lol = !reconnect(); if(!lol) { ok = true; _retryCount = 0; break; } _retryCount++; sleep(2); } } //_retryCount return ok; } void Connection::query(QSqlQuery& sql, QList<QVariant>& result) { if (!sql.exec()) { if (tryRetry(sql.lastError())) { if(isValid()) { QSqlQuery qs = createQuery(); cpQuery(sql, qs); Log::warn("   ..."); return query(qs, result); } else { throw exc::Message("    ");; } } else throw exc::Sql(sql); } ... }

Multithreaded Qt अनुप्रयोगों में DBMS कनेक्शन का उपयोग करना