🧜🏽 👩🏿‍⚖️ 👨🏾‍🔬 हम Android उपकरणों पर SQL प्रविष्टि की गति का अनुकूलन करते हैं 🛥️ 👨🏽‍🌾 🖖🏿

शुभ दोपहर

अपने एंड्रॉइड प्रोजेक्ट के विकास के दौरान, मुझे डिवाइस पर SQLite डेटाबेस में बड़ी संख्या में पंक्तियों को अपडेट करने के कार्य का सामना करना पड़ा।

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

कार्य का अधिक विस्तृत विवरण:

Android एप्लिकेशन को SQLite डेटाबेस के साथ (एपीके के अंदर, परिसंपत्ति में) वितरित किया गया था। डेटाबेस में शहरों की जानकारी थी। लेकिन जानकारी बुनियादी है, भाषा-स्वतंत्र, और भाषा-निर्भर क्षेत्र केवल अंग्रेजी में थे।
कार्यक्रम को सभी भाषाओं के साथ वितरित करना अवास्तविक होगा, जैसा कि डेटाबेस में प्रत्येक भाषा 1-2 mb से मूल एपीके फ़ाइल में इंस्टॉलर जोड़ देगी। और 11 भाषाओं का समर्थन किया गया था।

इसलिए, डेटाबेस के लिए भाषा पैच का आविष्कार किया गया था, जो इंटरनेट (सर्वर से) से डाउनलोड किया जाएगा, और पहले से ही डिवाइस पर आधार पर लुढ़का हुआ है।
पैच एक gzip-clamped टेक्स्ट फ़ाइल थी, जिसकी प्रत्येक पंक्ति में टैब (\ t) द्वारा अलग किए गए मान थे।

डाउनलोड करने में कोई समस्या नहीं थी। यह तेज है। लेकिन इस योजना की अड़चन डिवाइस पर डेटाबेस में प्रविष्टि है।
पहला विकल्प मैंने जावा में लिखा था जो एंड्रॉइड में निर्मित SQLite डेटाबेस के साथ काम करने की प्रसिद्ध विशेषताओं का उपयोग करता है।
प्रति पंक्ति 3 फ़ील्ड अपडेट करना आवश्यक था (पैच से मान जोड़ें)। यहाँ सिर्फ ऐसी लाइनें हैं जो भाषा के आधार पर 20,000 से 60,000 तक थीं।

जावा कोड का पहला संस्करण

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

try { buffRead = new BufferedReader(fileIn, (1000*1024)); // 1000 KB String line; int lineNum = 0; while ((line = buffRead.readLine()) != null) { try { String[] values = line.split("\t"); if (values.length < 2) // cause 3rd value van be empty { // some error, try next line continue; } int idInt = Integer.valueOf(values[0]); String name = values[1]; getDb().execSql("update " + getTableNabe() + " set " + lang.getColumnName() + " = ? where " + COLUMN_ID + " = ? ", new String[] { name, String.valueOf(idInt) }); getDb().execSql("update " + getTableNabe() + " set " + lang.getColumnSort() + " = ? where " + COLUMN_ID + " = ? ", new String[] { String.valueOf(lineNum++), String.valueOf(idInt) }); if (values.lengh == 3 && values[2].length != 0) { String data = values[2]; getDb().execSql("update "+ getTableNabe() + " set " + lang.getColumnData() + " = ? where " + COLUMN_ID + " = ? ", new String[] { data, String.valueOf(idInt) }); } } catch (NumberFormatException e) { e.printStackTrace(); return false; } catch (SQLException e) { e.printStackTrace(); return false; } createIndexOnLang(lang); }// end of while } catch (IOException e) { e.printStackTrace(); return false; } finally { if (buffRead != null) { try { buffRead.close(); } catch (IOException e) { e.printStackTrace(); } } } return true;

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

पाश से पहले जोड़ा गया

  getDb().beginTransaction();

चक्र के बाद जोड़ा गया

  getDb().setTransactionSuccessful();

और अंतिम ब्लॉक में

  getDb().endTransaction();

यह वृद्धि बड़ी नहीं थी। तब मुझे याद आया कि ग्रहण में, एंड्रॉइड डेवलपर टूल्स ( ADT ) को स्थापित करने के बाद, वहाँ एक उत्कृष्ट डीडीएमएस परिप्रेक्ष्य है, जिसमें एक उत्कृष्ट फ़ंक्शन प्रोफाइलिंग फ़ंक्शन है।

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

प्रदर्शन की कमियां

इस रूपरेखा तंत्र की मदद से, यह तुरंत स्पष्ट हो गया कि निम्नलिखित स्थानों में मेरे प्रदर्शन में गिरावट थी।
1. थूक एक बहुत ही धीमा तरीका है। यह किसी के लिए एक रहस्योद्घाटन नहीं हो सकता है, लेकिन मुझे आश्चर्य था।
2. प्रश्नों के लिए तार के साथ, तार के साथ काम करें। अंदर निष्पादित करें, जैसा कि आप देख सकते हैं, हर बार नए स्ट्रिंगरबिल्डर्स का एक गुच्छा लूप में बनाया गया था, जो तब बिना किसी आवश्यकता के फेंक दिए गए थे। जैसा कि उन्होंने यहां लिखा है , कभी भी साइकिल प्लस (+) के माध्यम से लाइनों को गोंद नहीं करती है। एक पूर्वनिर्धारित StringBuilder का उपयोग करें। और इससे भी बेहतर, सामान्य तौर पर, चक्र से पहले अग्रिम में लाइनें तैयार करें। जो, मेरे मामले में, सबसे स्पष्ट सुधार है।
3. Android पुस्तकालयों के अंदर ही SQL का काम करता है। वहां बहुत सारे ताले और अनलॉक बनाए गए थे। दस्तावेज़ीकरण पढ़ने के बाद , मुझे setLockingEnabled डेटाबेस में एक विधि मिली, इसे गलत करने के लिए, हमें गति में अच्छी वृद्धि मिली।
4. प्रत्येक निष्पादित कॉल के लिए SQLiteStatement तैयार करना। यह भी एक महंगा ऑपरेशन है। थोड़ा गुगली, मैंने पाया कि बयान, तार की तरह, पहले से तैयार किया जा सकता है, और एक लूप में, बस उन्हें मापदंडों को बांधें, और फिर उन्हें निष्पादित करें।

जावा कोड का दूसरा संस्करण

इन सभी समस्याओं को हल करने, विभाजन से छुटकारा पाने, लूप से SQLiteStatement तैयार करने, लूप से सभी स्ट्रिंग कार्य को हटाने, लूप से पहले getDb () जोड़ने से। SetLockingEnabled (झूठा), मुझे यह विकल्प मिला है।

 try { buffRead = new BufferedReader(fileIn, (1000*1024)); // 1000 KB String line; int lineNum = 0; checkDbErrors(); getDb().beginTransaction(); getDb().setLockingEnabled(false); // Prepare SQL queries String updateStatment = "update " + getTableName() + " set "; String whereStatment = " where " + COLUMN_ID + " = ?"; String updateNameSQL = updateStatment + lang.getColumns().getColumnName() + " = ? " + whereStatment; String updatqDataSQL = updateStatment + lang.getColumns().getColumnData() + " = ? " + whereStatment; String updatqSortSQL = updateStatment + lang.getColumns().getColumnSort() + " = ? " + whereStatment; SQLiteStatement updateName = getDb().compileStatement(updateNameSQL); SQLiteStatement updateData = getDb().compileStatement(updatqDataSQL); SQLiteStatement updateSort = getDb().compileStatement(updatqSortSQL); while ((line = buffRead.readLine()) != null) { try { int idInt = parseIdFromString(line); String name = parseNameFromString(line, line.indexOf('\t') + 1); String data= parseDataFromString(line, name.length() + 1); updateName.bindString(1, name); updateName.bindLong(2, idInt); updateName.execute(); if (data.length() != 0) { updateWiki.bindString(1, data); updateWiki.bindLong(2, idInt); updateWiki.execute(); } updateSort.bindLong(1, lineNum++); updateSort.bindLong(2, idInt); updateSort.execute(); } catch (NumberFormatException e) { e.printStackTrace(); return false; } catch (SQLException e) { e.printStackTrace(); return false; } } getDb().setTransactionSuccessful(); } catch (IOException e) { e.printStackTrace(); return false; } finally { getDb().endTransaction(); if (buffRead != null) { try { buffRead.close(); } catch (IOException e) { e.printStackTrace(); } } } return true;

तरीकों
parseIdFromString (स्ट्रिंग लाइन),
parseNameFromString (स्ट्रिंग लाइन, int से) और
parseDataFromString (String line, int from) बेहद अनाड़ी है, लेकिन विभाजन विकल्प की तुलना में तेजी से काम करता है

यहाँ वे हैं जो रुचि रखते हैं:

हेल्पर मेथड कोड

  private int parseIdFromString(String line) { int ind = line.indexOf('\t'); if (ind == -1) { return 0; } String idStr = line.substring(0, ind); int length = idStr.length(); if (length == 0) { return 0; } int result = 0; int zero = '0'; for (int i = 0; i < length; ++i) { result += (idStr.charAt(i) - zero) * Math.pow(10, length - i - 1); } return result; } private String parseNameFromString(String line, int from) { int ind = line.indexOf('\t', from); if (ind == -1) { return new String(); } return line.substring(from, ind); } private String parseDataFromString(String line, int from) { int ind = line.indexOf('\t', from); if (ind == -1) { return new String(); } return line.substring(from, ind); }

जैसा कि आप parseNameFromString में देख सकते हैं कि यहां तक कि स्ट्रिंग का एक ललाट अनुवाद इंट में है, लेकिन यह अनाड़ी संस्करण Integer.valueOf (प्रोफाइलर के माध्यम से सत्यापित) की तुलना में तेजी से काम करता है

नतीजतन, डेटाबेस में इस अपडेट विकल्प ने मूल एक की तुलना में दस गुना तेजी से काम किया। यानी एचटीसी डिजायर पर लगभग 1.5-2 मिनट में किए गए इस एल्गोरिदम को 43,000 लाइनों ने अपडेट किया

लेकिन, यह परिणाम मुझे संतुष्ट नहीं कर सका। जब तक हम डेटाबेस में अपनी जरूरत की भाषा नहीं डालते, तब तक कार्यक्रम के उपयोगकर्ता के लिए 2 मिनट इंतजार करना बहुत अच्छा नहीं है।

जावा के साथ, कोई व्यक्ति अभी भी शमन खेल सकता है, लेकिन परिमाण के आदेशों द्वारा गति को बढ़ाना संभव नहीं होगा, क्योंकि कोड के अंतिम संस्करण पर प्रोफाइलर को चलाने के परिणामों से स्पष्ट है कि अब एंड्रॉइड SDK \ source \ android- से native_exuteute () विधि के अंदर सबसे लंबा किया जाता है। 14 \ android \ डेटाबेस \ sqlite \ SQLiteStatement.java। यह c ++ में काम करने वाला एक देशी तरीका है
लेकिन इसके साथ-साथ, हमने किसी तरह के जादू लॉगटाइमस्टैट विधि में बहुत समय खो दिया, जिसकी आवश्यकता मुझे अभी भी समझ में नहीं आई थी, और इसे कैसे अक्षम किया जाए, भी। इसके अलावा, ऑपरेशन में बाइंडिंग बहुत तेजी से काम नहीं किया, और वास्तव में, यह जावा है ... यह किस तरह का प्रदर्शन हो सकता है (व्यंग्य, मेरे पास जावा के साथ कुछ भी गलत नहीं है)

हम C ++ में सब कुछ लिखते हैं

नतीजतन, मैंने जावा के साथ और अधिक परेशान न करने और C ++ में अपना इंसर्ट लिखने का फैसला किया (जैसा कि वे लाठी और ... के साथ कहते हैं)। NDK इकट्ठा करें और इसे JNI के माध्यम से जावा से कॉल करें।

इस विचार के साथ एक समस्या है: एनडीके के तहत साइक्लाइट कहां से प्राप्त करें? खैर, वास्तव में - प्राथमिक। हम स्रोत sqlite फ़ाइल से लेते हैं। साइट और इसे पूरी तरह से NDK के तहत अपने परिवाद में जोड़ें।

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

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

कहानी पर वापस।
मैंने अपना अपडेट लिखने का फैसला किया। SQLite घसीटा। C ++ कोड स्वयं उन सभी विचारों को दोहराता है जो पहले से जावा कोड में सुधार किए गए हैं।
साथ ही, इस लेख से मुझे बहुत मदद मिली। यह बहुत विस्तार से वर्णन करता है कि सम्मिलन की गति कैसे बढ़ाई जाए।

यह बहुत सारे कोड निकला, जो रुचि रखते हैं, देख सकते हैं

C ++ कोड

 std::vector<std::string>& split(const std::string &s, char delim, std::vector<std::string> &elems) { elems.clear(); std::stringstream ss(s); std::string item; while (std::getline(ss, item, delim)) { elems.push_back(item); } return elems; } std::string prepareUpdateStatment(std::string columnName, std::string columnValue, std::string id) { std::ostringstream constructor; constructor << "update cities set " << columnName << " = \"" << columnValue << "\" where _id = " << id; return constructor.str(); } std::string prepareUpdateStatmentForBind(std::string columnName) { std::ostringstream constructor; constructor << "update cities set " << columnName << " = ? where _id = ? "; return constructor.str(); } std::string getColumnName(std::string column, std::string lang) { std::ostringstream constructor; constructor << lang << "_" << column; return constructor.str(); } std::string parseInt(int i) { std::ostringstream ss; ss << i; return ss.str(); } bool pushToDBWithPreparedStatments(std::string line, sqlite3* db, std::string lang, int lineNum, sqlite3_stmt* stmtnUpdateName, sqlite3_stmt* stmtnUpdateSort, sqlite3_stmt* stmtnUpdateData) { if (line.size() == 0) { return true; // end of file } int error = SQLITE_OK; std::vector<std::string> elems; elems = split(line, '\t', elems); if (elems.size() < 2) { log("line parse error"); return false; } std::string& idStr = elems[0]; int idInt = atoi(idStr.c_str()); std::string& nameStr = elems[1]; sqlite3_bind_text(stmtnUpdateName, 1 , nameStr.c_str(), -1, SQLITE_STATIC); sqlite3_bind_int(stmtnUpdateName, 2 , idInt); if ((error = sqlite3_step(stmtnUpdateName)) != SQLITE_DONE) { logError(error, sqlite3_errmsg(db)); return false; } sqlite3_clear_bindings(stmtnUpdateName); sqlite3_reset(stmtnUpdateName); sqlite3_bind_int(stmtnUpdateSort, 1 , lineNum); sqlite3_bind_int(stmtnUpdateSort, 2 , idInt); if ((error = sqlite3_step(stmtnUpdateSort)) != SQLITE_DONE) { logError(error, sqlite3_errmsg(db)); return false; } sqlite3_clear_bindings(stmtnUpdateSort); sqlite3_reset(stmtnUpdateSort); if (elems.size() == 3) { std::string& DataStr = elems[2]; sqlite3_bind_text(stmtnUpdateData, 1 , DataStr.c_str(), -1, SQLITE_STATIC); sqlite3_bind_int(stmtnUpdateData, 2 , idInt); if ((error = sqlite3_step(stmtnUpdateData)) != SQLITE_DONE) { logError(error, sqlite3_errmsg(db)); return false; } sqlite3_clear_bindings(stmtnUpdateData); sqlite3_reset(stmtnUpdateData); } return true; } void parseAndUpdateDB(std::string databasePath, std::string patchPath, std::string lang) { time_t beforeStartTime = time(NULL); sqlite3* db; if (sqlite3_open_v2(databasePath.c_str(), &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_PRIVATECACHE, NULL) != SQLITE_OK) { logError("Error wile opening db", sqlite3_errmsg(db)); return; } std::string line; std::ifstream myfile(patchPath.c_str()); if (!myfile.is_open()) { log("Error wile opening patch file"); return; } int lineNum = 0; int error = SQLITE_OK; // Begin transaction if ( (error = sqlite3_exec(db, "begin", NULL, NULL, NULL)) != SQLITE_OK) { logError(error, sqlite3_errmsg(db)); return; } sqlite3_stmt* stmtnUpdateName; std::string updateName = prepareUpdateStatmentForBind(getColumnName("name", lang)); if ( (error = sqlite3_prepare(db, updateName.c_str(), updateName.length(), &stmtnUpdateName, NULL)) != SQLITE_OK) { logError(error, sqlite3_errmsg(db)); return; } sqlite3_stmt * stmtnUpdateSort; std::string updateSort = prepareUpdateStatmentForBind(getColumnName("sort", lang)); if ( (error = sqlite3_prepare(db, updateSort.c_str(), updateSort.length(), &stmtnUpdateSort, NULL)) != SQLITE_OK) { logError(error, sqlite3_errmsg(db)); return; } sqlite3_stmt * stmtnUpdateData; std::string updateData = prepareUpdateStatmentForBind(getColumnName("data", lang)); if ( (error = sqlite3_prepare(db, updateData.c_str(), updateData.length(), &stmtnUpdateData, NULL)) != SQLITE_OK) { logError(error, sqlite3_errmsg(db)); return; } // For fast work sqlite3_exec(db, "PRAGMA synchronous = OFF", NULL, NULL, NULL); sqlite3_exec(db, "PRAGMA journal_mode = MEMORY", NULL, NULL, NULL); while ( myfile.good() ) { std::getline(myfile, line); if (!pushToDBWithPreparedStatments(line, db, lang, lineNum++, stmtnUpdateName, stmtnUpdateSort, stmtnUpdateData)) { break; } } sqlite3_finalize(stmtnUpdateName); sqlite3_finalize(stmtnUpdateSort); sqlite3_finalize(stmtnUpdateData); // End transaction if ( (error = sqlite3_exec(db, "end", NULL, NULL, NULL)) != SQLITE_OK) { logError(error, sqlite3_errmsg(db)); return; } sqlite3_close(db); myfile.close(); time_t afterFinishTime = time(NULL); int result = afterFinishTime- beforeStartTime; log("result of run is %d secs" , result); }

वैसे, मैंने विजुअल स्टूडियो में विंडोज के तहत इस कोड को लिखा और डिबग किया, और फिर मैंने इसे NDK के तहत इकट्ठा किया, और एंड्रॉइड के तहत सब कुछ जादुई तरीके से काम किया।
कोड का संस्करण अंतिम नहीं है, इसलिए आपको कुछ सबसे अच्छे समाधानों के साथ गलती नहीं ढूंढनी चाहिए। कोड का सार यह दिखाने के लिए है कि जावा में C ++ में समान कैसे करें, लेकिन केवल C ++ में यह कई गुना तेजी से काम करेगा।

तो गति के बारे में।

डिबग (ग्रहण से जुड़े) के तहत एक ही एचटीसी डिजायर पर 43,000 लाइनों का एक ही इंसर्ट, लगभग 43 सेकंड में काम किया। यानी कहीं, 1 एमएस में एक लाइन। यदि आप ग्रहण और डिबग को काट देते हैं, तो आपको 20-25 सेकंड के क्षेत्र में वास्तव में तेजी से परिणाम मिलता है। एचटीसी वन एस जैसे अधिक शक्तिशाली उपकरणों पर, सम्मिलन प्रक्रिया में आमतौर पर लगभग 10-15 सेकंड लगते हैं। जो शुरुआती मिनटों की तुलना में दिखाता है कि उत्पादकता में सुधार के सभी प्रयास बेकार नहीं गए।

नैतिकता

अपने कार्य के उदाहरण का उपयोग करते हुए, मैंने दिखाया कि आप एंड्रॉइड के लिए विकसित होने पर SQLite के साथ काम को कैसे तेज कर सकते हैं (मूल स्तर पर संक्रमण के लिए)। मेरा तर्क है कि अभी भी ऐसा करने के लिए बहुत सारे विकल्प हैं, लेकिन मुझे लगता है कि यह जानकारी किसी को अपने अनुप्रयोगों को और भी अधिक संवेदनशील और तेज़ बनाने में मदद करेगी।

युपीडी:
धन्यवाद to_climb , एक और स्पष्ट सुधार का उल्लेख किया। 1n अनुरोध में गोंद 3 अद्यतन अनुरोध।
यानी 3 क़ानून नहीं, लेकिन कुछ लंबी प्रजातियां
अद्यतन तालिका सेट var1 = ?, var2 =? कहाँ _द =?

हम Android उपकरणों पर SQL प्रविष्टि की गति का अनुकूलन करते हैं