/* ** Add or remove the fault-simulation layer using sqlite3_config(). If ** the argument is non-zero, the */ static int faultsimInstall(int install){ static struct sqlite3_mem_methods m = { faultsimMalloc, /* xMalloc */ faultsimFree, /* xFree */ faultsimRealloc, /* xRealloc */ faultsimSize, /* xSize */ faultsimRoundup, /* xRoundup */ faultsimInit, /* xInit */ faultsimShutdown, /* xShutdown */ 0 /* pAppData */ }; int rc; install = (install ? 1 : 0); assert(memfault.isInstalled==1 || memfault.isInstalled==0); if( install==memfault.isInstalled ){ return SQLITE_ERROR; } if( install ){ rc = sqlite3_config(SQLITE_CONFIG_GETMALLOC, &memfault.m); assert(memfault.m.xMalloc); if( rc==SQLITE_OK ){ rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &m); } sqlite3_test_control(SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, faultsimBeginBenign, faultsimEndBenign ); }else{ sqlite3_mem_methods m2; assert(memfault.m.xMalloc); /* One should be able to reset the default memory allocator by storing ** a zeroed allocator then calling GETMALLOC. */ memset(&m2, 0, sizeof(m2)); sqlite3_config(SQLITE_CONFIG_MALLOC, &m2); sqlite3_config(SQLITE_CONFIG_GETMALLOC, &m2); assert( memcmp(&m2, &memfault.m, sizeof(m2))==0 ); rc = sqlite3_config(SQLITE_CONFIG_MALLOC, &memfault.m); sqlite3_test_control(SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, (void*)0, (void*)0); } if( rc==SQLITE_OK ){ memfault.isInstalled = 1; } return rc; }
/* Don't call this function directly! Use svn_atomic__init_once(). */ static svn_error_t * init_sqlite(void *baton, apr_pool_t *pool) { if (sqlite3_libversion_number() < SQLITE_VERSION_NUMBER) { return svn_error_createf(SVN_ERR_SQLITE_ERROR, NULL, _("SQLite compiled for %s, but running with %s"), SQLITE_VERSION, sqlite3_libversion()); } #if APR_HAS_THREADS #if SQLITE_VERSION_AT_LEAST(3,5,0) /* SQLite 3.5 allows verification of its thread-safety at runtime. Older versions are simply expected to have been configured with --enable-threadsafe, which compiles with -DSQLITE_THREADSAFE=1 (or -DTHREADSAFE, for older versions). */ if (! sqlite3_threadsafe()) return svn_error_create(SVN_ERR_SQLITE_ERROR, NULL, _("SQLite is required to be compiled and run in " "thread-safe mode")); #endif #if SQLITE_VERSION_AT_LEAST(3,6,0) /* If SQLite has been already initialized, sqlite3_config() returns SQLITE_MISUSE. */ { int err = sqlite3_config(SQLITE_CONFIG_MULTITHREAD); if (err != SQLITE_OK && err != SQLITE_MISUSE) return svn_error_create(SQLITE_ERROR_CODE(err), NULL, "Could not configure SQLite"); } SQLITE_ERR_MSG(sqlite3_initialize(), "Could not initialize SQLite"); #endif #endif /* APR_HAS_THRADS */ return SVN_NO_ERROR; }
void init_sqlite_memory() { fprintf(stdout, "Initializing sqlite memory configuration!\n"); if (sqlite3_config(SQLITE_CONFIG_MALLOC, &my_mem) != SQLITE_OK) { fprintf(stdout, "Failed to set custom sqlite memory allocator!\n"); } fprintf(stdout, "Success!\n"); }
Sqlite::Sqlite() { dbHandle = NULL; int out; sqlite3_config(SQLITE_CONFIG_URI, 1); std::string sqlString; std::string dbFile; dbFile = "file:"; dbFile.append(getenv("HOME")); dbFile.append("/files.db"); out = sqlite3_open_v2(dbFile.c_str(), &dbHandle, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, NULL); if (out != SQLITE_OK || dbHandle == NULL) { std::cerr << "(" << __FILE__ << ":" << __LINE__ << ") " << out << dbFile.c_str() << " - " << sqlite3_errmsg(dbHandle) << std::endl; } initialiseDatabase(); sqlString = "INSERT INTO gpsdata (time,latitude,longitude,altitude,heading) " "VALUES (?,?,?,?,?);"; out = sqlite3_prepare_v2(dbHandle, sqlString.c_str(), sqlString.length(), &insert, NULL); if (out != SQLITE_OK) { std::cerr << "(" << __FILE__ << ":" << __LINE__ << ") " << out << " - " << sqlite3_errmsg(dbHandle) << std::endl; } sqlString = "SELECT * FROM gpsdata " "WHERE pkey IS ?;"; out = sqlite3_prepare_v2(dbHandle, sqlString.c_str(), sqlString.length(), &query, NULL); if (out != SQLITE_OK) { std::cerr << "(" << __FILE__ << ":" << __LINE__ << ") " << out << " - " << sqlite3_errmsg(dbHandle) << std::endl; } // TODO Auto-generated constructor stub }
// initialize SQLite3 void database_init ( void ) { // local variables database_state_t *state = database_getState ( ); int status; // use thread safe serialized mode status = sqlite3_config ( SQLITE_CONFIG_SERIALIZED ); if ( SQLITE_OK != status ) { fatalError ( "Thread-safe SQLite3 not supported!", 1 ); } // initialize SQLite3 status = sqlite3_initialize ( ); if ( SQLITE_OK != status ) { fatalError ( "Failed to initialize SQLite3!", 1 ); } // open database status = sqlite3_open( DATABASE_FILE, &state->database ); if ( SQLITE_OK != status ) { fatalError ( "Failed to open SQLite3 database!", 1 ); } // initialize database database_loadFile ( state, DATABASE_SQL ); // prepare statements database_initStatements ( state ); }
OCStackResult PDMInit(const char *path) { int rc; const char *dbPath = NULL; if (SQLITE_OK != sqlite3_config(SQLITE_CONFIG_LOG, errLogCallback, NULL)) { OC_LOG(INFO, TAG, "Unable to enable debug log of sqlite"); } if (NULL == path || !*path) { dbPath = DB_FILE; } else { dbPath = path; } rc = sqlite3_open_v2(dbPath, &g_db, SQLITE_OPEN_READWRITE, NULL); if (SQLITE_OK != rc) { OC_LOG_V(INFO, TAG, "ERROR: Can't open database: %s", sqlite3_errmsg(g_db)); return createDB(dbPath); } gInit = true; return OC_STACK_OK; }
void svn_sqlite__dbg_enable_errorlog(void) { #if defined(SVN_DEBUG) && defined(SQLITE_CONFIG_LOG) sqlite3_config(SQLITE_CONFIG_LOG, sqlite_error_log, (void*)NULL /* baton */); #endif }
//--------------------------------------------------------------------------- bool CFS_Sqlite::Initialize(void* pEngine) { int ret=0; CON(MSG_INFO, _W("Database filesystem sqlite %s:"), _A2W(sqlite3_version) ); if (!sqlite3_threadsafe()) { CON(MSG_ERR, _W("... not compiled thread-safe - will not be used!")); return false; } CON(MSG_INFO, _W("... setting multithread configuration")); sqlite3_config(SQLITE_CONFIG_MULTITHREAD); ret = sqlite3_initialize(); if (ret == SQLITE_OK) CON(MSG_INFO, _W("... successfuly initialized")); else { CON(MSG_ERR, _W("... error code %d returned - will not be used!"), ret); return false; } return true; }
// Initialize library. // To be called once during the lifetime of the app. // $package: The folder where the package data resides. // $webroot: The document root folder for the web server. void bibledit_initialize_library (const char * package, const char * webroot) { // Must initialize libcurl before any threads are started. #ifdef HAVE_CLIENT #else curl_global_init (CURL_GLOBAL_ALL); #endif // Thread locking. thread_setup (); // Initialize SQLite: Full thread safety: https://www.sqlite.org/c3ref/threadsafe.html. // This is supported to prevent "database locked" errors. if (!sqlite3_threadsafe ()) { cerr << "SQLite is not threadsafe" << endl; } sqlite3_config (SQLITE_CONFIG_SERIALIZED); // Binary file mode on Windows. #ifdef HAVE_WINDOWS _set_fmode (_O_BINARY); #endif // Set the web root folder. config_globals_document_root = webroot; // Initialize SSL/TLS (after webroot has been set). filter_url_ssl_tls_initialize (); #ifndef HAVE_CLIENT // Cloud initializes OpenLDAP server access settings (after webroot has been set). ldap_logic_initialize (); #endif #ifdef HAVE_CLIENT // Set local timezone offset in the library. #ifdef HAVE_WINDOWS TIME_ZONE_INFORMATION tzi; DWORD dwRet = GetTimeZoneInformation (&tzi); (void)dwRet; int offset = 0 - (tzi.Bias / 60); bibledit_set_timezone_hours_offset_utc (offset); #else time_t t = time (NULL); struct tm lt = {}; localtime_r (&t, <); int offset = round (lt.tm_gmtoff / 3600); bibledit_set_timezone_hours_offset_utc (offset); #endif #endif // Initialize data in a thread. thread setup_thread = thread (setup_conditionally, package); setup_thread.detach (); // Multiple start/stop guard. bibledit_started = false; }
// 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(); }
int main() { std::ifstream in("data/data.json"); sqlite3* db; // std::remove("data.sqlite3"); sqlite3_config(SQLITE_CONFIG_SINGLETHREAD); int rc; rc = sqlite3_open("data.sqlite3", &db); assert(rc == SQLITE_OK); rc = sqlite3_exec(db, schema, NULL, NULL, NULL); assert(rc == SQLITE_OK); sqlite3_stmt* insert; rc = sqlite3_prepare_v2(db, insert_stmt, -1, &insert, NULL); while (!in.eof()) { Json::Value root; char comment[512000]; in.getline(comment, 512000); size_t clen = std::strlen(comment); //comment[clen++] = '}'; //comment[clen] = 0; char* cstart = comment; while (cstart != comment + clen && *cstart != '{') ++cstart; if (cstart == comment + clen) continue; //std::cout << cstart << std::endl; std::stringstream cstream(cstart); cstream >> root; assert(root.type() == Json::ValueType::objectValue); bind_text(insert, 1, root, "name", Json::nullValue); bind_text(insert, 2, root, "link_id"); bind_text(insert, 3, root, "created_utc"); sqlite3_bind_int64(insert, 4, root.get("ups", 0).asInt64()); sqlite3_bind_int64(insert, 5, root.get("downs", 0).asInt64()); sqlite3_bind_int64(insert, 6, root.get("gilded", 0).asInt64()); bind_text(insert, 7, root, "author"); sqlite3_bind_int64(insert, 8, root.get("score", 0).asInt64()); bind_text(insert, 9, root, "subreddit"); bind_text(insert, 10, root, "subreddit_id"); bind_text(insert, 11, root, "parent_id", Json::nullValue); bind_text(insert, 12, root, "author_flair_text", Json::nullValue); bind_text(insert, 13, root, "body"); rc = sqlite3_step(insert); assert(rc == SQLITE_DONE); sqlite3_reset(insert); } sqlite3_finalize(insert); sqlite3_close(db); }
NMBLSEXPORT void handleLoadLibrary(boost::asio::io_service &, std::string root, bool debug) { docroot = root; worker_thread.create_thread(sqliteworker); std::cout << "Hi form handle load lib" << std::endl; is_running_as_debug = debug; sqlite3_config(SQLITE_CONFIG_SINGLETHREAD); }
sqlite3 *db_sqlite_init(char *filename) { sqlite3_config(SQLITE_CONFIG_SERIALIZED); if(sqlite3_open(filename, &db) != SQLITE_OK) { fprintf(stderr, "[-] sqlite: cannot open sqlite databse: <%s>\n", sqlite3_errmsg(db)); return NULL; } sqlite3_busy_timeout(db, 30000); return db; }
static void installInitWrappers(void){ sqlite3_mutex_methods mutexmethods = { wrMutexInit, wrMutexEnd, wrMutexAlloc, wrMutexFree, wrMutexEnter, wrMutexTry, wrMutexLeave, wrMutexHeld, wrMutexNotheld }; sqlite3_pcache_methods pcachemethods = { 0, wrPCacheInit, wrPCacheShutdown, wrPCacheCreate, wrPCacheCachesize, wrPCachePagecount, wrPCacheFetch, wrPCacheUnpin, wrPCacheRekey, wrPCacheTruncate, wrPCacheDestroy }; sqlite3_mem_methods memmethods = { wrMemMalloc, wrMemFree, wrMemRealloc, wrMemSize, wrMemRoundup, wrMemInit, wrMemShutdown, 0 }; memset(&wrapped, 0, sizeof(wrapped)); sqlite3_shutdown(); sqlite3_config(SQLITE_CONFIG_GETMUTEX, &wrapped.mutex); sqlite3_config(SQLITE_CONFIG_GETMALLOC, &wrapped.mem); sqlite3_config(SQLITE_CONFIG_GETPCACHE, &wrapped.pcache); sqlite3_config(SQLITE_CONFIG_MUTEX, &mutexmethods); sqlite3_config(SQLITE_CONFIG_MALLOC, &memmethods); sqlite3_config(SQLITE_CONFIG_PCACHE, &pcachemethods); }
/* ** This routine is the only routine in this file with external linkage. ** ** Populate the low-level memory allocation function pointers in ** sqlite3GlobalConfig.m with pointers to the routines in this file. */ void sqlite3MemSetDefault(void){ static const sqlite3_mem_methods defaultMethods = { sqlite3MemMalloc, sqlite3MemFree, sqlite3MemRealloc, sqlite3MemSize, sqlite3MemRoundup, sqlite3MemInit, sqlite3MemShutdown, 0 }; sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods); }
RmSwapTable *rm_swap_table_open(gboolean in_memory, GError **error) { RmSwapTable *self = NULL; char *path = NULL; if(in_memory) { path = g_strdup(":memory:"); } else { char pid[20] = {0}; memset(pid, 0, sizeof(pid)); g_snprintf(pid, sizeof(pid), "%d", getpid()); path = g_build_filename(g_get_user_cache_dir(), "rmlint", pid, NULL); /* Make sure that path actually exists */ rm_swap_table_create_cachedir(error); } /* Might happen if no tmp file could be created */ if(error && *error) { goto cleanup; } /* We do locking ourselves */ sqlite3_config(SQLITE_CONFIG_SINGLETHREAD); sqlite3 *handle = NULL; if(sqlite3_open(path, &handle) != SQLITE_OK) { SET_ERROR("Cannot open swap table db"); goto cleanup; } /* Finetune sqlite (quite slow without these) */ sqlite3_extended_result_codes(handle, TRUE); sqlite3_exec(handle, "PRAGMA cache_size = 8000;", 0, 0, 0); sqlite3_exec(handle, "PRAGMA synchronous = OFF;", 0, 0, 0); sqlite3_exec(handle, "PRAGMA journal_mode = MEMORY;", 0, 0, 0); sqlite3_enable_shared_cache(TRUE); size_t path_len = strlen(path) + 1; self = g_malloc(sizeof(RmSwapTable) + path_len); self->cache = handle; self->attrs = g_ptr_array_new(); self->transaction_running = FALSE; strncpy(self->path, path, path_len); g_mutex_init(&self->mtx); cleanup: g_free(path); return self; }
static OCStackResult initializeDatabase(const char *path) { if (SQLITE_OK == sqlite3_config(SQLITE_CONFIG_LOG, errorCallback)) { OIC_LOG_V(INFO, TAG, "SQLite debugging log initialized."); } sqlite3_open_v2(!path ? RD_PATH : path, &gRDDB, SQLITE_OPEN_READONLY, NULL); if (!gRDDB) { return OC_STACK_ERROR; } return OC_STACK_OK; }
// register the logging func on sqlite. needs to be done BEFORE any sqlite3 func is called. static void registerLoggingFunc(const char *path) { static bool loggingFuncSet = false; if (loggingFuncSet) { return; } LOGV("Registering sqlite logging func \n"); int err = sqlite3_config(SQLITE_CONFIG_LOG, &sqlLogger, (void *)createStr(path)); if (err != SQLITE_OK) { LOGE("sqlite_config failed error_code = %d. THIS SHOULD NEVER occur.\n", err); return; } loggingFuncSet = true; }
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); } }
// register the logging func on sqlite. needs to be done BEFORE any sqlite3 func is called. static void registerLoggingFunc(const char *path) { static bool loggingFuncSet = false; if (loggingFuncSet) { return; } LOGV("Registering sqlite logging func \n"); int err = sqlite3_config(SQLITE_CONFIG_LOG, &sqlLogger, (void *)createStr(path, 0)); if (err != SQLITE_OK) { LOGW("sqlite returned error = %d when trying to register logging func.\n", err); return; } loggingFuncSet = true; }
int main(int argc, char **argv) { struct tm tm; // pid = getpid(); init_abt_log(NULL, LOG_NOTICE); if (sqlite3_config(SQLITE_CONFIG_MULTITHREAD) != SQLITE_OK) { //多线程模式防止并发锁 log_error(LOG_ERROR, "mutile thread error"); } if (init_ds3231() < 0) { log_error(LOG_EMERG, "init_ds3231"); return -1; } getTime(&tm); if (cache_init() < 0) { log_error(LOG_EMERG, "cache_init"); return -1; } if (init_at24c02b() < 0) { log_error(LOG_NOTICE, "init_at24c02b"); } g_dev_version = zigdev_version(); if (zigdev_init() < 0) { log_error(LOG_NOTICE, "zigdev_init"); return -1; } signal_propose(); zigdev_test(); //zigadd_dev(0x256833, 1, 1, 0, 1); tcp_server(NULL); cache_destroy(); close_abt_log(); return 0; }
int main(void) { /* Determina l'opzione di configurazione relativa al multithreading, che non necessita peraltro di ulteriore argomento */ sqlite3_config(SQLITE_CONFIG_MULTITHREAD); // Inizializzazione della libreria if (sqlite3_initialize() == SQLITE_OK) printf("Library: \'%s\' initialized\n", sqlite3_libversion()); // Rilascio delle risorse if (sqlite3_shutdown() == SQLITE_OK) printf("Library: freed\n"); return(EXIT_SUCCESS); }
static void _mapcache_cache_sqlite_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) { ezxml_t cur_node; mapcache_cache_sqlite *dcache; sqlite3_initialize(); sqlite3_config(SQLITE_CONFIG_MULTITHREAD); dcache = (mapcache_cache_sqlite*) cache; if ((cur_node = ezxml_child(node, "base")) != NULL) { ctx->set_error(ctx, 500, "sqlite config <base> not supported anymore, use <dbfile>"); return; } if ((cur_node = ezxml_child(node, "dbname_template")) != NULL) { ctx->set_error(ctx, 500, "sqlite config <dbname_template> not supported anymore, use <dbfile>"); return; } if ((cur_node = ezxml_child(node, "dbfile")) != NULL) { dcache->dbfile = apr_pstrdup(ctx->pool, cur_node->txt); } dcache->detect_blank = 0; if ((cur_node = ezxml_child(node, "detect_blank")) != NULL) { if(!strcasecmp(cur_node->txt,"true")) { dcache->detect_blank = 1; } } if ((cur_node = ezxml_child(node, "hitstats")) != NULL) { if (!strcasecmp(cur_node->txt, "true")) { ctx->set_error(ctx, 500, "sqlite config <hitstats> not supported anymore"); } } if ((cur_node = ezxml_child(node, "pragma")) != NULL) { dcache->pragmas = apr_table_make(ctx->pool,1); while(cur_node) { char *name = (char*)ezxml_attr(cur_node,"name"); if(!name || !cur_node->txt || !strlen(cur_node->txt)) { ctx->set_error(ctx,500,"<pragma> missing name attribute"); return; } apr_table_set(dcache->pragmas,name,cur_node->txt); cur_node = cur_node->next; } } if (!dcache->dbfile) { ctx->set_error(ctx, 500, "sqlite cache \"%s\" is missing <dbfile> entry", cache->name); return; } }
bool Utility::setThreadMode(int mode) { #if (SQLITE_THREADSAFE != 0) if (SQLITE_OK == sqlite3_shutdown()) { if (SQLITE_OK == sqlite3_config(mode)) { _threadMode = mode; if (SQLITE_OK == sqlite3_initialize()) return true; } sqlite3_initialize(); } #endif return false; }
bool kvdb_init() { #ifdef DEBUG int rc; KVASSERT(!_initialized, "kvdb_init called more than once"); _initialized = true; rc = sqlite3_config(SQLITE_CONFIG_LOG, _sqlite_log, _sqlite_log); if (rc) { KVDEBUG("got %d when setting up log", rc); return false; } #endif /* DEBUG */ return true; }
/* ** This function is called during initialization (sqlite3_initialize()) to ** install the default pluggable cache module, assuming the user has not ** already provided an alternative. */ void sqlite3PCacheSetDefault(void){ static sqlite3_pcache_methods defaultMethods = { 0, /* pArg */ pcache1Init, /* xInit */ pcache1Shutdown, /* xShutdown */ pcache1Create, /* xCreate */ pcache1Cachesize, /* xCachesize */ pcache1Pagecount, /* xPagecount */ pcache1Fetch, /* xFetch */ pcache1Unpin, /* xUnpin */ pcache1Rekey, /* xRekey */ pcache1Truncate, /* xTruncate */ pcache1Destroy /* xDestroy */ }; sqlite3_config(SQLITE_CONFIG_PCACHE, &defaultMethods); }
int mansearch_setup(int start) { static void *pagecache; int c; #define PC_PAGESIZE 1280 #define PC_NUMPAGES 256 if (start) { if (NULL != pagecache) { fprintf(stderr, "pagecache already enabled\n"); return((int)MANDOCLEVEL_BADARG); } pagecache = mmap(NULL, PC_PAGESIZE * PC_NUMPAGES, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0); if (MAP_FAILED == pagecache) { perror("mmap"); pagecache = NULL; return((int)MANDOCLEVEL_SYSERR); } c = sqlite3_config(SQLITE_CONFIG_PAGECACHE, pagecache, PC_PAGESIZE, PC_NUMPAGES); if (SQLITE_OK == c) return((int)MANDOCLEVEL_OK); fprintf(stderr, "pagecache: %s\n", sqlite3_errstr(c)); } else if (NULL == pagecache) { fprintf(stderr, "pagecache missing\n"); return((int)MANDOCLEVEL_BADARG); } if (-1 == munmap(pagecache, PC_PAGESIZE * PC_NUMPAGES)) { perror("munmap"); pagecache = NULL; return((int)MANDOCLEVEL_SYSERR); } pagecache = NULL; return((int)MANDOCLEVEL_OK); }
StorageHandler::StorageHandler( const string &directory, const string &dataBaseName, Logger &logger): mDirectory(directory), mDataBaseName(dataBaseName), mTrustLineHandler(connection(dataBaseName, directory), kTrustLineTableName, logger), mPaymentOperationStateHandler(connection(dataBaseName, directory), kPaymentOperationStateTableName, logger), mTransactionHandler(connection(dataBaseName, directory), kTransactionTableName, logger), mHistoryStorage(connection(dataBaseName, directory), kHistoryMainTableName, kHistoryAdditionalTableName, logger), mBlackListHandler(connection(dataBaseName, directory), kBlackListTableName, logger), mNodeFeaturesHandler(connection(dataBaseName, directory), kNodeFeaturesTableName, logger), mLog(logger) { sqlite3_config(SQLITE_CONFIG_SINGLETHREAD); }
int SQL_init(struct SQLiteSession * sqlserver , const char * dbFilename) { if (sqlite3_config(SQLITE_CONFIG_SERIALIZED)!=SQLITE_OK) { fprintf(stderr,"Cannot set SQLite to serialized mode , cannot continue we are not going to be thread safe..!"); return 0; } sqlserver->rc = sqlite3_open(dbFilename, &sqlserver->db); if (sqlserver->rc != SQLITE_OK) { fprintf(stderr, "Cannot open database: %s\n", sqlite3_errmsg(sqlserver->db)); sqlite3_close(sqlserver->db); return 0; } return 1; }
static void _mapcache_cache_sqlite_configuration_parse_xml(mapcache_context *ctx, ezxml_t node, mapcache_cache *cache, mapcache_cfg *config) { ezxml_t cur_node; mapcache_cache_sqlite *dcache; sqlite3_initialize(); sqlite3_config(SQLITE_CONFIG_MULTITHREAD); dcache = (mapcache_cache_sqlite*)cache; if ((cur_node = ezxml_child(node,"base")) != NULL) { dcache->dbname_template = apr_pstrcat(ctx->pool,cur_node->txt,"/{tileset}#{grid}.db",NULL); } if ((cur_node = ezxml_child(node,"dbname_template")) != NULL) { dcache->dbname_template = apr_pstrdup(ctx->pool,cur_node->txt); } if ((cur_node = ezxml_child(node,"hitstats")) != NULL) { if(!strcasecmp(cur_node->txt,"true")) { dcache->hitstats = 1; } } if(!dcache->dbname_template) { ctx->set_error(ctx,500,"sqlite cache \"%s\" is missing <dbname_template> entry",cache->name); return; } }