मैं नहीं लगता कि दो डेटाबेस संलग्न और INSERT INTO foo (SELECT * FROM bar) चल रहा यह करने के लिए सबसे तेज़ तरीका है। यदि आप हैंडहेल्ड डिवाइस और सर्वर (या कोई अन्य डिवाइस) के बीच सिंक कर रहे हैं तो परिवहन तंत्र बाधा बन सकता है? या पहले से ही एक ही फाइलिसम पर दो डेटाबेस फाइलें हैं? यदि डिवाइस पर फाइल सिस्टम धीमी फ्लैश-मेमोरी है, तो क्या यह एक बाधा हो सकती है?
क्या आप अपने डिवाइस पर कच्चे SQLite C कोड को संकलित/चलाने में सक्षम हैं? (मुझे लगता है कि रॉ sqlite3 समामेलन WinCE/मोबाइल के लिए संकलन चाहिए) यदि हां, तो और आप तैयार हैं:
- कुछ सी कोड (SQLite सी एपीआई का उपयोग) द्वारा डेटा हानि की
- बढ़ाएँ जोखिम लिखने के लिए डिस्क जर्नलिंग
दो डेटाबेसों के बीच 100K रिकॉर्ड्स को कॉपी/सिंक्रनाइज़ करने के लिए एक छोटे से स्टैंड-अलोन निष्पादन योग्य लिखना संभव होना चाहिए।
मैं से कुछ पोस्ट किया है कि यहाँ क्या मैं SQLite के अनुकूलन के बारे में सीखा सम्मिलित करता है: Improve INSERT-per-second performance of SQLite?
संपादित करें:वास्तविक कोड के साथ इस बाहर की कोशिश की ...
मुझे नहीं पता विंडोज मोबाइल निष्पादन योग्य बनाने में शामिल सभी कदमों को जानें, लेकिन SQLite3 amalgamation को विजुअल स्टूडियो का उपयोग करके बॉक्स के बाहर संकलित करना चाहिए। यहां एक नमूना main.c कार्यक्रम दो SQLite डेटाबेस खुलती (दोनों एक ही स्कीमा करना होगा - #define TABLE बयान देखें) है और एक SELECT कथन निष्पादित करता है और फिर एक सम्मिलित कथन के परिणामस्वरूप पंक्तियों बांधता:
/*************************************************************
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "sqlite3.h"
#define SOURCEDB "C:\\source.sqlite"
#define DESTDB "c:\\dest.sqlite"
#define TABLE "CREATE TABLE IF NOT EXISTS TTC (id INTEGER PRIMARY KEY, Route_ID TEXT, Branch_Code TEXT, Version INTEGER, Stop INTEGER, Vehicle_Index INTEGER, Day Integer, Time TEXT)"
#define BUFFER_SIZE 256
int main(int argc, char **argv) {
sqlite3 * sourceDB;
sqlite3 * destDB;
sqlite3_stmt * insertStmt;
sqlite3_stmt * selectStmt;
char * insertTail = 0;
char * selectTail = 0;
int n = 0;
int result = 0;
char * sErrMsg = 0;
clock_t cStartClock;
char sInsertSQL [BUFFER_SIZE] = "\0";
char sSelectSQL [BUFFER_SIZE] = "\0";
/* Open the Source and Destination databases */
sqlite3_open(SOURCEDB, &sourceDB);
sqlite3_open(DESTDB, &destDB);
/* Risky - but improves performance */
sqlite3_exec(destDB, "PRAGMA synchronous = OFF", NULL, NULL, &sErrMsg);
sqlite3_exec(destDB, "PRAGMA journal_mode = MEMORY", NULL, NULL, &sErrMsg);
cStartClock = clock(); /* Keep track of how long this took*/
/* Prepared statements are much faster */
/* Compile the Insert statement */
sprintf(sInsertSQL, "INSERT INTO TTC VALUES (NULL, @RT, @BR, @VR, @ST, @VI, @DT, @TM)");
sqlite3_prepare_v2(destDB, sInsertSQL, BUFFER_SIZE, &insertStmt, &insertTail);
/* Compile the Select statement */
sprintf(sSelectSQL, "SELECT * FROM TTC LIMIT 100000");
sqlite3_prepare_v2(sourceDB, sSelectSQL, BUFFER_SIZE, &selectStmt, &selectTail);
/* Transaction on the destination database */
sqlite3_exec(destDB, "BEGIN TRANSACTION", NULL, NULL, &sErrMsg);
/* Execute the Select Statement. Step through the returned rows and bind
each value to the prepared insert statement. Obviously this is much simpler
if the columns in the select statement are in the same order as the columns
in the insert statement */
result = sqlite3_step(selectStmt);
while (result == SQLITE_ROW)
{
sqlite3_bind_text(insertStmt, 1, sqlite3_column_text(selectStmt, 1), -1, SQLITE_TRANSIENT); /* Get Route */
sqlite3_bind_text(insertStmt, 2, sqlite3_column_text(selectStmt, 2), -1, SQLITE_TRANSIENT); /* Get Branch */
sqlite3_bind_text(insertStmt, 3, sqlite3_column_text(selectStmt, 3), -1, SQLITE_TRANSIENT); /* Get Version */
sqlite3_bind_text(insertStmt, 4, sqlite3_column_text(selectStmt, 4), -1, SQLITE_TRANSIENT); /* Get Stop Number */
sqlite3_bind_text(insertStmt, 5, sqlite3_column_text(selectStmt, 5), -1, SQLITE_TRANSIENT); /* Get Vehicle */
sqlite3_bind_text(insertStmt, 6, sqlite3_column_text(selectStmt, 6), -1, SQLITE_TRANSIENT); /* Get Date */
sqlite3_bind_text(insertStmt, 7, sqlite3_column_text(selectStmt, 7), -1, SQLITE_TRANSIENT); /* Get Time */
sqlite3_step(insertStmt); /* Execute the SQL Insert Statement (Destination Database)*/
sqlite3_clear_bindings(insertStmt); /* Clear bindings */
sqlite3_reset(insertStmt); /* Reset VDBE */
n++;
/* Fetch next from from source database */
result = sqlite3_step(selectStmt);
}
sqlite3_exec(destDB, "END TRANSACTION", NULL, NULL, &sErrMsg);
printf("Transfered %d records in %4.2f seconds\n", n, (clock() - cStartClock)/(double)CLOCKS_PER_SEC);
sqlite3_finalize(selectStmt);
sqlite3_finalize(insertStmt);
/* Close both databases */
sqlite3_close(destDB);
sqlite3_close(sourceDB);
return 0;
}
पर मेरी विंडोज डेस्कटॉप मशीन यह कोड 1.20 सेकंड में source.sqlite से dest.sqlite से 100k रिकॉर्ड कॉपी करता है। मुझे नहीं पता कि फ्लैश मेमोरी के साथ मोबाइल डिवाइस पर आप किस प्रकार का प्रदर्शन देखेंगे (लेकिन मैं उत्सुक हूं)।
आपके मौजूदा प्रश्न की निरंतरता की तरह लगता है ?? http://stackoverflow.com/questions/2121336/insert-takes-too-long-code-optimization-needed – AdaTheDev
यह है, मुझे नहीं पता कि मैं अपने धागे के लिए कैसे उत्तर दे सकता हूं, मैं केवल पोस्ट पर टिप्पणी कर सकता हूं, या इसका उत्तर दो .... लेकिन मैं एक और सवाल उठाना चाहता हूं ... – Pentium10
प्रत्येक पंक्ति कैसी दिखती है? 100,000 रिकॉर्ड बहुत अधिक पंक्तियां छोटी नहीं हैं। हम नियमित रूप से 300,000 रिकॉर्ड के साथ डेटा आयात चलाते हैं और यह कुछ सेकंड में चलता है (जिसे हम धीमे मानते हैं)। –