void SqliteFinalize(TPerfTestMode aMode) { if(aMode == EPerfTestSqliteSqlMode) { (void)sqlite3_enable_shared_cache(0); sqlite3_soft_heap_limit(0); } sqlite3_shutdown(); }
/** @SYMTestCaseID SYSLIB-SQL-UT-3433 @SYMTestCaseDesc Test for DEF104744 - RSqlStatement::Next() SQL Server crashes on ORDER BY clause. The test creates a database with a table with 30 integer columns, then inserts 100 records. After that, sets the soft heap limit to be very low - 10K (to get sqlite3_release_memory() called by SQLITE ), creates a statement object and attempts to retrieve the inserted records in descending order. @SYMTestPriority High @SYMTestActions Test for DEF104744 - RSqlStatement::Next() SQL Server crashes on ORDER BY clause. @SYMTestExpectedResults Test must not fail @SYMDEF DEF104744 */ void DEF104744() { (void)TheFs.Delete(KTestDatabase); TheSqliteDb = NULL; TInt err = sqlite3_open((const char*)KTestDatabaseZ().Ptr(), &TheSqliteDb); TEST2(err, SQLITE_OK); _LIT8(KCreateTblSqlZ, "CREATE TABLE A1(F1 INTEGER,F2 INTEGER,F3 INTEGER,F4 INTEGER,F5 INTEGER,F6 INTEGER,F7 INTEGER,F8 INTEGER,F9 INTEGER,F10 INTEGER,F11 INTEGER,F12 INTEGER,F13 INTEGER,F14 INTEGER,F15 INTEGER,F16 INTEGER,F17 INTEGER,F18 INTEGER,F19 INTEGER,F20 INTEGER,F21 INTEGER,F22 INTEGER,F23 INTEGER,F24 INTEGER,F25 INTEGER,F26 INTEGER,F27 INTEGER,F28 INTEGER,F29 INTEGER,F30 INTEGER)\x0"); err = sqlite3_exec(TheSqliteDb, (const char*)KCreateTblSqlZ().Ptr(), 0, 0, 0); TEST2(err, SQLITE_OK); //Insert a 100 records const TInt KTestRecCnt = 100; _LIT8(KInsertSqlZ, "INSERT INTO A1(F1,F2 ,F3 ,F4 ,F5 ,F6 ,F7 ,F8 ,F9 ,F10,F11,F12,F13,F14,F15,F16,F17,F18,F19,F20,F21,F22,F23,F24,F25,F26,F27,F28,F29,F30) VALUES(:Prm1,:Prm2,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296,4294967296)\x0"); sqlite3_stmt* stmt1 = NULL; err = sqlite3_prepare_v2(TheSqliteDb, (const char*)(KInsertSqlZ().Ptr()), -1, &stmt1, NULL); TEST2(err, SQLITE_OK); _LIT8(KBeginSqlZ, "BEGIN\x0"); err = sqlite3_exec(TheSqliteDb, (const char*)KBeginSqlZ().Ptr(), 0, 0, 0); TEST2(err, SQLITE_OK); for(TInt i=0;i<KTestRecCnt;++i) { err = sqlite3_bind_int(stmt1, 1, i); TEST2(err, SQLITE_OK); err = sqlite3_bind_int(stmt1, 2, i + 1); TEST2(err, SQLITE_OK); err = sqlite3_step(stmt1); TEST2(err, SQLITE_DONE); err = sqlite3_reset(stmt1); TEST2(err, SQLITE_OK); TInt cnt = sqlite3_changes(TheSqliteDb); TEST2(cnt, 1); } _LIT8(KCommitSqlZ, "COMMIT\x0"); err = sqlite3_exec(TheSqliteDb, (const char*)KCommitSqlZ().Ptr(), 0, 0, 0); TEST2(err, SQLITE_OK); sqlite3_finalize(stmt1); sqlite3_soft_heap_limit(10 * 1024);//Setting very low soft heap limit - 10K // Get the inserted record data in descending order. sqlite3_stmt* stmt2 = NULL; _LIT8(KSelectSqlZ,"SELECT * FROM A1 ORDER BY F1 DESC"); err = sqlite3_prepare_v2(TheSqliteDb, (const char*)(KSelectSqlZ().Ptr()), -1, &stmt2, NULL); TEST2(err, SQLITE_OK); err = sqlite3_step(stmt2); TEST2(err, SQLITE_ROW); sqlite3_finalize(stmt2); sqlite3_close(TheSqliteDb); TheSqliteDb = NULL; (void)TheFs.Delete(KTestDatabase); }
void SqliteInitialize(TPerfTestMode aMode) { if(aMode == EPerfTestSqliteSqlMode) { const TInt KSqliteLookAsideCellSize = 128; const TInt KSqliteLookAsideCellCount = 512; int err; err = sqlite3_config(SQLITE_CONFIG_LOOKASIDE, KSqliteLookAsideCellSize, KSqliteLookAsideCellCount); TEST2(err, SQLITE_OK); sqlite3_soft_heap_limit(1024 * 1024); err = sqlite3_enable_shared_cache(1); TEST2(err, SQLITE_OK); } }
// Sets the global SQLite configuration. // This must be called before any other SQLite functions are called. static void sqliteInitialize() { // Enable multi-threaded mode. In this mode, SQLite is safe to use by multiple // threads as long as no two threads use the same database connection at the same // time (which we guarantee in the SQLite database wrappers). sqlite3_config(SQLITE_CONFIG_MULTITHREAD); // Redirect SQLite log messages to the Android log. bool verboseLog = android_util_Log_isVerboseLogEnabled(SQLITE_LOG_TAG); sqlite3_config(SQLITE_CONFIG_LOG, &sqliteLogCallback, verboseLog ? (void*)1 : NULL); // The soft heap limit prevents the page cache allocations from growing // beyond the given limit, no matter what the max page cache sizes are // set to. The limit does not, as of 3.5.0, affect any other allocations. sqlite3_soft_heap_limit(SOFT_HEAP_LIMIT); // Initialize SQLite. sqlite3_initialize(); }
/* public native void dbopen(String path, int flags, String locale); */ static void dbopen(JNIEnv* env, jobject object, jstring pathString, jint flags) { int err; sqlite3 * handle = NULL; sqlite3_stmt * statement = NULL; char const * path8 = env->GetStringUTFChars(pathString, NULL); int sqliteFlags; // register the logging func on sqlite. needs to be done BEFORE any sqlite3 func is called. registerLoggingFunc(path8); // convert our flags into the sqlite flags if (flags & CREATE_IF_NECESSARY) { sqliteFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE; } else if (flags & OPEN_READONLY) { sqliteFlags = SQLITE_OPEN_READONLY; } else { sqliteFlags = SQLITE_OPEN_READWRITE; } err = sqlite3_open_v2(path8, &handle, sqliteFlags, NULL); if (err != SQLITE_OK) { LOGE("sqlite3_open_v2(\"%s\", &handle, %d, NULL) failed\n", path8, sqliteFlags); throw_sqlite3_exception(env, handle); goto done; } // The soft heap limit prevents the page cache allocations from growing // beyond the given limit, no matter what the max page cache sizes are // set to. The limit does not, as of 3.5.0, affect any other allocations. sqlite3_soft_heap_limit(sSqliteSoftHeapLimit); // Set the default busy handler to retry for 1000ms and then return SQLITE_BUSY err = sqlite3_busy_timeout(handle, 1000 /* ms */); if (err != SQLITE_OK) { LOGE("sqlite3_busy_timeout(handle, 1000) failed for \"%s\"\n", path8); throw_sqlite3_exception(env, handle); goto done; } #ifdef DB_INTEGRITY_CHECK static const char* integritySql = "pragma integrity_check(1);"; err = sqlite3_prepare_v2(handle, integritySql, -1, &statement, NULL); if (err != SQLITE_OK) { LOGE("sqlite_prepare_v2(handle, \"%s\") failed for \"%s\"\n", integritySql, path8); throw_sqlite3_exception(env, handle); goto done; } // first is OK or error message err = sqlite3_step(statement); if (err != SQLITE_ROW) { LOGE("integrity check failed for \"%s\"\n", integritySql, path8); throw_sqlite3_exception(env, handle); goto done; } else { const char *text = (const char*)sqlite3_column_text(statement, 0); if (strcmp(text, "ok") != 0) { LOGE("integrity check failed for \"%s\": %s\n", integritySql, path8, text); jniThrowException(env, "android/database/sqlite/SQLiteDatabaseCorruptException", text); goto done; } } #endif err = register_android_functions(handle, UTF16_STORAGE); if (err) { throw_sqlite3_exception(env, handle); goto done; } LOGV("Opened '%s' - %p\n", path8, handle); env->SetIntField(object, offset_db_handle, (int) handle); handle = NULL; // The caller owns the handle now. done: // Release allocated resources if (path8 != NULL) env->ReleaseStringUTFChars(pathString, path8); if (statement != NULL) sqlite3_finalize(statement); if (handle != NULL) sqlite3_close(handle); }
int main(int argc, char *argv[]) { int stcp = -1; int sudp = -1; int rc = -1; if (argc != 2) { fprintf(stderr, "Usage: %s [port]\n", argv[0]); exit(1); } /* Limit memory usage by SQLite to a reasonable, relatively small level. */ #ifdef WWDEBUG printf("Current SQLite heap size limit is %ld. Setting it to 8MB.\n", sqlite3_soft_heap_limit(-1)); #endif sqlite3_soft_heap_limit(8*1024*1024); #ifdef WWDEBUG printf("New SQLite heap size limit is %ld.\n", sqlite3_soft_heap_limit(-1)); #endif /* Include this only if we are *not* compiling a debug version */ #ifndef WWDEBUG /* Fork and background (basically) */ pid_t pid = fork(); if (pid != 0) { if (pid < 0) { perror("AGGREGATOR: Failed to fork"); exit(1); } exit(0); } #endif bzero(sock_data, sizeof(sock_data)); // Get the database ready // Attempt to open database & check for failure #ifdef WWDEBUG printf("Attempting to open database: %s\n", SQLITE_DB_FNAME); #endif rc = sqlite3_open(SQLITE_DB_FNAME, &db); if (rc) { fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db)); sqlite3_close(db); exit(1); } else { // Now check & create tables if required createTable(db, 1); createTable(db, 2); #ifdef WWDEBUG printf("Database ready for reading and writing...\n"); #endif } // Prepare to accept clients FD_ZERO(&rfds); FD_ZERO(&wfds); // Open TCP (SOCK_STREAM) & UDP (SOCK_DGRAM) sockets, bind to the port // given and listen on TCP sock for connections if ((setup_sockets(atoi(argv[1]), &stcp, &sudp)) < 0) { perror("WWAGGREGATOR: Error setting up Sockets\n"); exit(1); } #ifdef WWDEBUG printf("Our listen sock # is - %d & UDP sock # is - %d \n", stcp, sudp); #endif //printf("FD_SETSIZE - %d\n",FD_SETSIZE); //Add the created TCP & UDP sockets to the read set of file descriptors FD_SET(stcp, &rfds); FD_SET(sudp, &rfds); // Event loop while (1) { int n = 0; fd_set _rfds, _wfds; memcpy(&_rfds, &rfds, sizeof(fd_set)); memcpy(&_wfds, &wfds, sizeof(fd_set)); // Block until there's an event to handle // Select function call is made; return value 'n' gives the number of FDs ready to be serviced if (((n = select(FD_SETSIZE, &_rfds, &_wfds, NULL, 0)) < 0) && (errno != EINTR)) { perror("select"); exit(1); } // Handle events for (int i = 0; (i < FD_SETSIZE) && n; i++) { if (FD_ISSET(i, &_rfds)) { // Handle our main mother, TCP listening socket differently if (i == stcp) { if (accept_conn(stcp) < 0) exit(1); // Handle our UDP socket differently } else if (i == sudp) { read_and_dump_data(sudp); } else { #ifdef WWDEBUG fprintf(stderr, "File descriptor %d is ready for reading .. call'g readHLR\n", i); #endif read_handler(i); } n--; } if (FD_ISSET(i, &_wfds)) { #ifdef WWDEBUG fprintf(stderr, "File descriptor %d is ready for writing .. call'g writeHLR\n", i); #endif write_handler(i); n--; } } } }
void Connector::enableSoftHeapLimit(int limit) { sqlite3_soft_heap_limit(limit); }
/* public native void dbopen(String path, int flags, String locale); */ static void dbopen(JNIEnv* env, jobject object, jstring pathString, jint flags) { int err; sqlite3 * handle = NULL; sqlite3_stmt * statement = NULL; char const * path8 = env->GetStringUTFChars(pathString, NULL); int sqliteFlags; // Error code handling for SQLite exec char* zErrMsg = NULL; // register the logging func on sqlite. needs to be done BEFORE any sqlite3 func is called. registerLoggingFunc(path8); // convert our flags into the sqlite flags if (flags & CREATE_IF_NECESSARY) { sqliteFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE; } else if (flags & OPEN_READONLY) { sqliteFlags = SQLITE_OPEN_READONLY; } else { sqliteFlags = SQLITE_OPEN_READWRITE; } err = sqlite3_open_v2(path8, &handle, sqliteFlags, NULL); if (err != SQLITE_OK) { LOGE("sqlite3_open_v2(\"%s\", &handle, %d, NULL) failed\n", path8, sqliteFlags); throw_sqlite3_exception(env, handle); goto done; } // WAL is a new rollback method available in SQLite v3.7+. WAL speeds up writes to // SQLite databases. WAL cannot be used with Read Only databases or databases opened // in read only mode. // Check if DB can use WAL mode; Open in WAL mode for non-ReadOnly DBs if(!(flags & OPEN_READONLY) && (use_wal_mode(path8))) { // Configure databases to run in WAL mode. err = sqlite3_exec(handle,"PRAGMA journal_mode = WAL;", NULL, NULL,&zErrMsg); if (SQLITE_OK != err) { LOGE("sqlite3_exec - Failed to set WAL mode for [%s] \n", path8); err = sqlite3_exec(handle,"PRAGMA journal_mode = DELETE;", NULL, NULL,&zErrMsg); if(SQLITE_OK != err) { LOGE("sqlite3_exec - Failed to set DELETE mode for [%s] \n", path8); throw_sqlite3_exception(env, handle); goto done; } } else { LOGI("WAL succesfuly enabled for [%s] \n", path8); // Set autocheckpoint = 100 pages err = sqlite3_wal_autocheckpoint(handle, 100); if (SQLITE_OK != err) { LOGE("sqlite3_exec to set WAL autocheckpoint failed\n"); throw_sqlite3_exception(env, handle); goto done; } else if (use_wal_mode(path8) == 2) { /* Try to disable fsyncs. We don't care if it fails */ sqlite3_exec(handle,"PRAGMA synchronous = OFF;", NULL, NULL,&zErrMsg); } } } // The soft heap limit prevents the page cache allocations from growing // beyond the given limit, no matter what the max page cache sizes are // set to. The limit does not, as of 3.5.0, affect any other allocations. sqlite3_soft_heap_limit(SQLITE_SOFT_HEAP_LIMIT); // Set the default busy handler to retry for 1000ms and then return SQLITE_BUSY err = sqlite3_busy_timeout(handle, 1000 /* ms */); if (err != SQLITE_OK) { LOGE("sqlite3_busy_timeout(handle, 1000) failed for \"%s\"\n", path8); throw_sqlite3_exception(env, handle); goto done; } #ifdef DB_INTEGRITY_CHECK static const char* integritySql = "pragma integrity_check(1);"; err = sqlite3_prepare_v2(handle, integritySql, -1, &statement, NULL); if (err != SQLITE_OK) { LOGE("sqlite_prepare_v2(handle, \"%s\") failed for \"%s\"\n", integritySql, path8); throw_sqlite3_exception(env, handle); goto done; } // first is OK or error message err = sqlite3_step(statement); if (err != SQLITE_ROW) { LOGE("integrity check failed for \"%s\"\n", integritySql, path8); throw_sqlite3_exception(env, handle); goto done; } else { const char *text = (const char*)sqlite3_column_text(statement, 0); if (strcmp(text, "ok") != 0) { LOGE("integrity check failed for \"%s\": %s\n", integritySql, path8, text); jniThrowException(env, "android/database/sqlite/SQLiteDatabaseCorruptException", text); goto done; } } #endif err = register_android_functions(handle, UTF16_STORAGE); if (err) { throw_sqlite3_exception(env, handle); goto done; } LOGV("Opened '%s' - %p\n", path8, handle); env->SetIntField(object, offset_db_handle, (int) handle); handle = NULL; // The caller owns the handle now. done: // Release allocated resources if (path8 != NULL) env->ReleaseStringUTFChars(pathString, path8); if (statement != NULL) sqlite3_finalize(statement); if (handle != NULL) sqlite3_close(handle); }