static void *sqlite_open_conn(const DBConf *db_conf) { sqlite *db = NULL; SQLiteConf *conf = db_conf->sqlite; /* make compiler happy */ char *errmsg = 0; /* sanity check */ if (conf == NULL) return NULL; if ((db = sqlite_open(octstr_get_cstr(conf->file), 0, &errmsg)) == NULL) { error(0, "SQLite: can not open database file `%s'!", octstr_get_cstr(conf->file)); error(0, "SQLite: %s", errmsg); goto failed; } if (conf->lock_timeout > 0) { info(0, "SQLite: Setting lock timeout to %ld", conf->lock_timeout); sqlite_busy_timeout(db, conf->lock_timeout); } info(0, "SQLite: Opened database file `%s'.", octstr_get_cstr(conf->file)); info(0, "SQLite: library version %s.", sqlite_version); return db; failed: return NULL; }
static apr_dbd_t *dbd_sqlite_open(apr_pool_t * pool, const char *params_) { apr_dbd_t *sql; sqlite *conn = NULL; char *perm; int iperms = 600; char* params = apr_pstrdup(pool, params_); /* params = "[filename]:[permissions]" * example: "shopping.db:600" */ perm = strstr(params, ":"); if (perm) { *(perm++) = '\x00'; /* split the filename and permissions */ if (strlen(perm) > 0) iperms = atoi(perm); } conn = sqlite_open(params, iperms, NULL); sql = apr_pcalloc(pool, sizeof(*sql)); sql->conn = conn; return sql; }
/* _sqlite2_init */ static SQLite2 * _sqlite2_init(Config * config, char const * section) { SQLite2 * sqlite; char const * name; char * error = NULL; if((sqlite = object_new(sizeof(*sqlite))) == NULL) return NULL; sqlite->handle = NULL; if((name = config_get(config, section, "filename")) != NULL && (sqlite->handle = sqlite_open(name, 0, &error)) == NULL) { error_set_code(1, "%s: %s", name, (error != NULL) ? error : "Unknown error"); free(error); } /* check for errors */ if(sqlite->handle == NULL) { _sqlite2_destroy(sqlite); return NULL; } return sqlite; }
bool cSQLiteDriver::open( int ) { char* error = NULL; close(); connection = sqlite_open( _dbname.latin1(), 0, &error ); if ( !connection ) { if ( error ) { QString err( error ); sqlite_freemem( error ); throw err; } else { throw QString( "Unknown SQLite error while opening database." ); } } exec( "PRAGMA synchronous = OFF;" ); exec( "PRAGMA default_synchronous = OFF;" ); exec( "PRAGMA full_column_names = OFF;" ); exec( "PRAGMA show_datatypes = OFF;" ); exec( "PRAGMA parser_trace = OFF;" ); return true; }
void SqliteDatabaseConnector::openDatabase() { #if defined(HAVE_SQLITE3_H) int result = sqlite3_open(db_name.c_str(), &db); if (result != SQLITE_OK) { std::string error = sqlite3_errmsg(db); logger << ERROR << "Unable to open database: " << db_name << " : " << endl; throw SqliteDatabaseConnectorException(error); } #elif defined(HAVE_SQLITE_H) char* errormsg = 0; db = sqlite_open(db_name.c_str(), 0, &errormsg); if (db == 0) { std::string error; if (errormsg != 0) { error = errormsg; } #ifdef HAVE_STDLIB_H free(errormsg); #endif logger << ERROR << "Unable to open database: " << db_name << " : " << endl; throw SqliteDatabaseConnectorException(error); } #endif }
/* SQLite dbs have no user name, passwords, hosts or ports. just file names. */ bool QSQLite2Driver::open(const QString & db, const QString &, const QString &, const QString &, int, const QString &) { if (isOpen()) close(); if (db.isEmpty()) return false; char* err = 0; d->access = sqlite_open(QFile::encodeName(db), 0, &err); if (err) { setLastError(QSqlError(tr("Error opening database"), QString::fromAscii(err), QSqlError::ConnectionError)); sqlite_freemem(err); err = 0; } if (d->access) { setOpen(true); setOpenError(false); return true; } setOpenError(true); return false; }
IoObject *IoSQLite_open(IoSQLite *self, IoObject *locals, IoMessage *m) { /*doc SQLite open(optionalPathString) Opens the database.Returns self on success or nil upon failure. If the databse is locked, "yield" will be called until it is accessable or timeoutSeconds has expired. */ char *zErrMsg; if (DATA(self)->debugOn) { IoState_print_(IOSTATE, "IoSQLite opening '%s'\n", CSTRING(DATA(self)->path)); } DATA(self)->db = sqlite_open(CSTRING(DATA(self)->path), 0, &zErrMsg); if (!DATA(self)->db) { IoSQLite_error_(self, zErrMsg); } else { IoSQLite_error_(self, ""); } sqlite_busy_handler(DATA(self)->db, IoSQLite_busyHandler, self); sqlite_busy_timeout(DATA(self)->db, DATA(self)->timeoutSeconds*1000); return self; }
int main(int argc, char **argv){ int i; sqlite *db; char *zErr; int status; int parent = getpid(); unlink("test.db"); unlink("test.db-journal"); db = sqlite_open("test.db", 0, &zErr); if( db==0 ){ printf("Cannot initialize: %s\n", zErr); return 1; } sqlite_exec(db, "CREATE TABLE t1(a,b)", 0, 0, 0); sqlite_close(db); for(i=0; i<10000; i++){ int pid = fork(); if( pid==0 ){ sched_yield(); do_some_sql(parent); return 0; } printf("test %d, pid=%d\n", i, pid); usleep(rand()%10000 + 1000); kill(pid, SIGKILL); waitpid(pid, &status, 0); } return 0; }
bool kr_dbConnect (KR_API *db) { db->c = sqlite_open (db->database, 0644, &db->dberr); if ( db->c == NULL ) { kr_dbError (db); return false; } return true; }
/* ** Make sure the database is open. If it is not, then open it. If ** the database fails to open, print an error message and exit. */ static void open_db(struct callback_data *p){ if( p->db==0 ){ char *zErrMsg = 0; p->db = db = sqlite_open(p->zDbFilename, 0666, &zErrMsg); if( db==0 ){ p->db = db = sqlite_open(p->zDbFilename, 0444, &zErrMsg); if( db==0 ){ if( zErrMsg ){ fprintf(stderr,"Unable to open database \"%s\": %s\n", p->zDbFilename, zErrMsg); }else{ fprintf(stderr,"Unable to open database %s\n", p->zDbFilename); } exit(1); }else{ fprintf(stderr,"Database \"%s\" opened READ ONLY!\n", p->zDbFilename); } } } }
/* * smb_nic_dbcreate * * Creates the host database based on the defined SQL statement. * It also initializes db_info table. */ static int smb_nic_dbcreate(void) { sqlite *db = NULL; char *errmsg = NULL; int rc, err = SMB_NIC_SUCCESS; (void) unlink(SMB_NIC_DB_NAME); db = sqlite_open(SMB_NIC_DB_NAME, 0600, &errmsg); if (db == NULL) { syslog(LOG_ERR, "Failed to create host database (%s).", NULL_MSGCHK(errmsg)); sqlite_freemem(errmsg); return (SMB_NIC_DBOPEN_FAILED); } sqlite_busy_timeout(db, SMB_NIC_DB_TIMEOUT); rc = sqlite_exec(db, "BEGIN TRANSACTION", NULL, NULL, &errmsg); if (rc != SQLITE_OK) { syslog(LOG_ERR, "Failed to create host database. Unable to " \ "begin database transaction (%s).", NULL_MSGCHK(errmsg)); sqlite_freemem(errmsg); sqlite_close(db); return (SMB_NIC_DBEXEC_FAILED); } if (sqlite_exec(db, SMB_NIC_DB_SQL, NULL, NULL, &errmsg) == SQLITE_OK) { rc = sqlite_exec(db, "COMMIT TRANSACTION", NULL, NULL, &errmsg); if (rc == SQLITE_OK) err = smb_nic_dbsetinfo(db); if (err != SMB_NIC_SUCCESS) rc = sqlite_exec(db, "ROLLBACK TRANSACTION", NULL, NULL, &errmsg); } else { syslog(LOG_ERR, "Failed to create host database. Unable to " \ "initialize host database (%s).", NULL_MSGCHK(errmsg)); sqlite_freemem(errmsg); rc = sqlite_exec(db, "ROLLBACK TRANSACTION", NULL, NULL, &errmsg); } if (rc != SQLITE_OK) { /* this is bad - database may be left in a locked state */ syslog(LOG_ERR, "Failed to create host database. Unable to " \ "close a transaction (%s).", NULL_MSGCHK(errmsg)); sqlite_freemem(errmsg); err = SMB_NIC_DBINIT_FAILED; } (void) sqlite_close(db); return (err); }
static void *worker_bee(void *pArg){ const char *zFilename = (char*)pArg; char *azErr; int i, cnt; int t = atoi(zFilename); char **az; sqlite *db; pthread_mutex_lock(&lock); thread_cnt++; pthread_mutex_unlock(&lock); printf("%s: START\n", zFilename); fflush(stdout); for(cnt=0; cnt<10; cnt++){ db = sqlite_open(&zFilename[2], 0, &azErr); if( db==0 ){ fprintf(stdout,"%s: can't open\n", zFilename); Exit(1); } sqlite_busy_handler(db, db_is_locked, zFilename); db_execute(db, zFilename, "CREATE TABLE t%d(a,b,c);", t); for(i=1; i<=100; i++){ db_execute(db, zFilename, "INSERT INTO t%d VALUES(%d,%d,%d);", t, i, i*2, i*i); } az = db_query(db, zFilename, "SELECT count(*) FROM t%d", t); db_check(zFilename, "tX size", az, "100", 0); az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t); db_check(zFilename, "tX avg", az, "101", 0); db_execute(db, zFilename, "DELETE FROM t%d WHERE a>50", t); az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t); db_check(zFilename, "tX avg2", az, "51", 0); for(i=1; i<=50; i++){ char z1[30], z2[30]; az = db_query(db, zFilename, "SELECT b, c FROM t%d WHERE a=%d", t, i); sprintf(z1, "%d", i*2); sprintf(z2, "%d", i*i); db_check(zFilename, "readback", az, z1, z2, 0); } db_execute(db, zFilename, "DROP TABLE t%d;", t); sqlite_close(db); } printf("%s: END\n", zFilename); /* unlink(zFilename); */ fflush(stdout); pthread_mutex_lock(&lock); thread_cnt--; if( thread_cnt<=0 ){ pthread_cond_signal(&sig); } pthread_mutex_unlock(&lock); return 0; }
int SqliteDatabase::connect() { disconnect(); if (conn = sqlite_open(db.c_str(),0,NULL)) { //cout << "Connected!\n"; char* err=NULL; if (setErr(sqlite_exec(getHandle(),"PRAGMA empty_result_callbacks=ON",NULL,NULL,&err),"PRAGMA empty_result_callbacks=ON") != SQLITE_OK) { return DB_CONNECTION_NONE; } active = true; return DB_CONNECTION_OK; } return DB_CONNECTION_NONE; };
static apr_dbd_t *dbd_sqlite_open(apr_pool_t * pool, const char *params_, const char **error) { apr_dbd_t *sql; sqlite *conn = NULL; char *perm; int iperms = 600; char* params = apr_pstrdup(pool, params_); /* params = "[filename]:[permissions]" * example: "shopping.db:600" */ perm = strstr(params, ":"); if (perm) { *(perm++) = '\x00'; /* split the filename and permissions */ if (strlen(perm) > 0) iperms = atoi(perm); } if (error) { *error = NULL; conn = sqlite_open(params, iperms, (char **)error); if (*error) { apr_pool_cleanup_register(pool, *error, error_free, apr_pool_cleanup_null); } } else { conn = sqlite_open(params, iperms, NULL); } sql = apr_pcalloc(pool, sizeof(*sql)); sql->conn = conn; return sql; }
// Make sure the database is open. If it is not, then open it. If // the database fails to open, print an error message and exit. static void open_db(struct callback_data *p){ if( p->db==0 ){ char *zErrMsg=0; db=p->db=sqlite_open(p->zDbFilename, 0, &zErrMsg); if( p->db==0 ){ if( zErrMsg ){ fprintf(stderr,"Unable to open database \"%s\": %s\n", p->zDbFilename, zErrMsg); }else{ fprintf(stderr,"Unable to open database %s\n", p->zDbFilename); } exit(1); } } }
/* * smb_nic_dbopen * * Opens host database with the given mode. */ static sqlite * smb_nic_dbopen(int mode) { sqlite *db; char *errmsg = NULL; db = sqlite_open(SMB_NIC_DB_NAME, mode, &errmsg); if (db == NULL) { syslog(LOG_ERR, "Failed to open host database: %s (%s).", SMB_NIC_DB_NAME, NULL_MSGCHK(errmsg)); sqlite_freemem(errmsg); } return (db); }
bool DatabaseSqlite::Initialize(const char *infoString) { char *errmsg; mSqlite = sqlite_open(infoString, 0, &errmsg); if (!mSqlite) { if (errmsg) sqlite_freemem(errmsg); return false; } return true; }
static int sqlite_load_module(void) { char *zErr; char fn[PATH_MAX]; int res; /* is the database there? */ snprintf(fn, sizeof(fn), "%s/astdb.db", ast_config_AST_LOG_DIR); db = sqlite_open(fn, 0660, &zErr); if (!db) { ast_log(LOG_ERROR, "app_dbsqlite: %s\n", zErr); free(zErr); return -1; } /* is the table there? */ res = sqlite_exec(db, "SELECT COUNT(Id) FROM astdb;", NULL, NULL, &zErr); if (res) { res = sqlite_exec(db, sql_create_table, NULL, NULL, &zErr); if (res) { ast_log(LOG_ERROR, "app_dbsqlite: Unable to create table 'astdb': %s\n", zErr); free(zErr); goto err; } /* TODO: here we should probably create an index */ } res = ast_register_application (g_app, sqliteget_exec, g_synopsis, g_descrip); if (!res) res = ast_register_application (p_app, sqliteput_exec, p_synopsis, p_descrip); if (!res) res = ast_register_application (d_app, sqlitedel_exec, d_synopsis, d_descrip); if (!res) res = ast_register_application (dt_app, sqlitedeltree_exec, dt_synopsis, dt_descrip); if (res) { ast_log(LOG_ERROR, "Unable to register app_dbsqlite\n"); return -1; } return 0; err: if (db) sqlite_close(db); return -1; }
static int SQLite2_connect (dbconn_t * c, const char * host, const char * database, const char * username, const char * password) { c->SQLite2.handle = sqlite_open(database, 0666, &c->SQLite2.errormsg); if (!c->SQLite2.handle) { sqlite_close(c->SQLite2.handle); return 0; } c->SQLite2.nrows = 0; c->SQLite2.ncolumns = 0; c->SQLite2.last_row = 0; c->SQLite2.step_res = 0; c->SQLite2.values = NULL; c->SQLite2.col_names = NULL; c->SQLite2.vm = NULL; return 1; }
static int load_module(void) { char *zErr; char fn[PATH_MAX]; int res; /* is the database there? */ snprintf(fn, sizeof(fn), "%s/cdr.db", ast_config_AST_LOG_DIR); db = sqlite_open(fn, 0660, &zErr); if (!db) { ast_log(LOG_ERROR, "cdr_sqlite: %s\n", zErr); free(zErr); return -1; } /* is the table there? */ res = sqlite_exec(db, "SELECT COUNT(id) FROM cdr;", NULL, NULL, NULL); if (res) { res = sqlite_exec(db, sql_create_table, NULL, NULL, &zErr); if (res) { ast_log(LOG_ERROR, "cdr_sqlite: Unable to create table 'cdr': %s\n", zErr); free(zErr); goto err; } /*res = sqlite_exec(db, sql_create_trigger, NULL, NULL, &zErr); if (res) { ast_log(LOG_ERROR, "cdr_sqlite: Unable to create maxentries trigger: %s\n", zErr); free(zErr); goto err; }*/ /* TODO: here we should probably create an index */ } res = ast_cdr_register(name, ast_module_info->description, sqlite_log); if (res) { ast_log(LOG_ERROR, "Unable to register SQLite CDR handling\n"); return -1; } return 0; err: if (db) sqlite_close(db); return -1; }
SmoothedCountPlugin::SmoothedCountPlugin(Configuration* config, ContextTracker* ct) : Plugin(config, ct, "SmoothedCountPlugin", "SmoothedCountPlugin, a linear interpolating unigram bigram trigram plugin", "SmoothedCountPlugin, long description." ) { Value value; try { value = config->get(LOGGER); logger << setlevel(value); logger << INFO << "LOGGER: " << value << endl; } catch (Configuration::ConfigurationException ex) { logger << WARN << "Caught ConfigurationException: " << ex.what() << endl; } try { value = config->get(UNIGRAM_WEIGHT); unigram_weight = toDouble(value); value = config->get(BIGRAM_WEIGHT); bigram_weight = toDouble(value); value = config->get(TRIGRAM_WEIGHT); trigram_weight = toDouble(value); value = config->get(DBFILENAME); dbfilename = value; } catch (Configuration::ConfigurationException ex) { logger << ERROR << "Caught fatal ConfigurationException: " << ex.what() << endl; throw PresageException("Unable to init " + name + " predictive plugin."); } // open database #if defined(HAVE_SQLITE3_H) int result = sqlite3_open(dbfilename.c_str(), &db); assert(result == SQLITE_OK); #elif defined(HAVE_SQLITE_H) db = sqlite_open(dbfilename.c_str(), 0777, NULL); assert(db != NULL); #endif }
/* ** Connects to a data source. */ static int env_connect(lua_State *L) { const char *sourcename; sqlite *conn; char *errmsg; getenvironment(L); /* validate environment */ sourcename = luaL_checkstring(L, 2); conn = sqlite_open(sourcename, 0, &errmsg); if (conn == NULL) { lua_pushnil(L); lua_pushliteral(L, LUASQL_PREFIX); lua_pushstring(L, errmsg); sqlite_freemem(errmsg); lua_concat(L, 2); return 2; } return create_connection(L, 1, conn); }
static int load_module(void) { char *zErr; char fn[PATH_MAX]; int res; ast_log(LOG_NOTICE, "This module has been marked deprecated in favor of " "using cdr_sqlite3_custom.\n"); /* is the database there? */ snprintf(fn, sizeof(fn), "%s/cdr.db", ast_config_AST_LOG_DIR); db = sqlite_open(fn, AST_FILE_MODE, &zErr); if (!db) { ast_log(LOG_ERROR, "cdr_sqlite: %s\n", zErr); ast_free(zErr); return AST_MODULE_LOAD_DECLINE; } /* is the table there? */ res = sqlite_exec(db, "SELECT COUNT(AcctId) FROM cdr;", NULL, NULL, NULL); if (res) { res = sqlite_exec(db, sql_create_table, NULL, NULL, &zErr); if (res) { ast_log(LOG_ERROR, "cdr_sqlite: Unable to create table 'cdr': %s\n", zErr); ast_free(zErr); goto err; } /* TODO: here we should probably create an index */ } res = ast_cdr_register(name, ast_module_info->description, sqlite_log); if (res) { ast_log(LOG_ERROR, "Unable to register SQLite CDR handling\n"); return AST_MODULE_LOAD_DECLINE; } return AST_MODULE_LOAD_SUCCESS; err: if (db) sqlite_close(db); return AST_MODULE_LOAD_DECLINE; }
/* ** Make sure the database is open. If it is not, then open it. If ** the database fails to open, print an error message and exit. */ static void open_db(struct callback_data *p){ if( p->db==0 ){ char *zErrMsg = 0; #ifdef SQLITE_HAS_CODEC int n = p->zKey ? strlen(p->zKey) : 0; db = p->db = sqlite_open_encrypted(p->zDbFilename, p->zKey, n, 0, &zErrMsg); #else db = p->db = sqlite_open(p->zDbFilename, 0, &zErrMsg); #endif if( p->db==0 ){ if( zErrMsg ){ fprintf(stderr,"Unable to open database \"%s\": %s\n", p->zDbFilename, zErrMsg); }else{ fprintf(stderr,"Unable to open database %s\n", p->zDbFilename); } exit(1); } } }
static void do_some_sql(int parent){ char *zErr; int rc = SQLITE_OK; sqlite *db; int cnt = 0; static char zBig[] = "-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" "-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; if( access("./test.db-journal",0)==0 ){ /*printf("pid %d: journal exists. rollback will be required\n",getpid());*/ unlink("test.db-saved"); system("cp test.db test.db-saved"); unlink("test.db-journal-saved"); system("cp test.db-journal test.db-journal-saved"); } db = sqlite_open("./test.db", 0, &zErr); if( db==0 ){ printf("ERROR: %s\n", zErr); if( strcmp(zErr,"database disk image is malformed")==0 ){ kill(parent, SIGKILL); } exit(1); } srand(getpid()); while( rc==SQLITE_OK ){ cnt++; rc = sqlite_exec_printf(db, "INSERT INTO t1 VALUES(%d,'%d%s')", 0, 0, &zErr, rand(), rand(), zBig); } if( rc!=SQLITE_OK ){ printf("ERROR #%d: %s\n", rc, zErr); if( rc==SQLITE_CORRUPT ){ kill(parent, SIGKILL); } } printf("pid %d: cnt=%d\n", getpid(), cnt); }
/* ** Usage: sqlite_open filename ** ** Returns: The name of an open database. */ static int sqlite_test_open( void *NotUsed, Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ int argc, /* Number of arguments */ char **argv /* Text of each argument */ ){ sqlite *db; char *zErr = 0; char zBuf[100]; if( argc!=2 ){ Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], " FILENAME\"", 0); return TCL_ERROR; } db = sqlite_open(argv[1], 0666, &zErr); if( db==0 ){ Tcl_AppendResult(interp, zErr, 0); free(zErr); return TCL_ERROR; } if( makePointerStr(interp, zBuf, db) ) return TCL_ERROR; Tcl_AppendResult(interp, zBuf, 0); return TCL_OK; }
/* SQLite dbs have no user name, passwords, hosts or ports. just file names. */ bool QSQLiteDriver::open(const QString & db, const QString &, const QString &, const QString &, int, const QString &) { if (isOpen()) close(); if (db.isEmpty()) return FALSE; char* err = 0; d->access = sqlite_open(QFile::encodeName(db), 0, &err); if (err) { setLastError(QSqlError("Error to open database", err, QSqlError::Connection)); sqlite_freemem(err); err = 0; } if (d->access) { setOpen(TRUE); setOpenError(FALSE); return TRUE; } setOpenError(TRUE); return FALSE; }
static int sqlite_odbx_bind( odbx_t* handle, const char* database, const char* who, const char* cred, int method ) { struct sconn* aux = handle->aux; if( aux == NULL ) { return -ODBX_ERR_PARAM; } if( method != ODBX_BIND_SIMPLE ) { return -ODBX_ERR_NOTSUP; } aux->errmsg = NULL; size_t flen = strlen( database ) + 1; if( ( aux->path = realloc( aux->path, aux->pathlen + flen + 1 ) ) == NULL ) { return -ODBX_ERR_NOMEM; } snprintf( aux->path + aux->pathlen, flen + 1, "%s", database ); /* The second parameter is currently unused. */ if( ( handle->generic = (void*) sqlite_open( aux->path, 0, NULL ) ) == NULL ) { aux->errno = SQLITE_CANTOPEN; aux->errmsg = (char*) dgettext( "opendbx", sqlite_odbx_errmsg[0] ); return -ODBX_ERR_BACKEND; } int err; if( ( err = sqlite_exec( (sqlite*) handle->generic, "PRAGMA empty_result_callbacks = ON;", NULL, NULL, NULL ) ) != SQLITE_OK ) { aux->errno = err; aux->errmsg = (char*) sqlite_error_string( err ); return -ODBX_ERR_BACKEND; } return ODBX_ERR_SUCCESS; }
/* ** sqlite DBNAME FILENAME ?MODE? ?-key KEY? ** ** This is the main Tcl command. When the "sqlite" Tcl command is ** invoked, this routine runs to process that command. ** ** The first argument, DBNAME, is an arbitrary name for a new ** database connection. This command creates a new command named ** DBNAME that is used to control that connection. The database ** connection is deleted when the DBNAME command is deleted. ** ** The second argument is the name of the directory that contains ** the sqlite database that is to be accessed. ** ** For testing purposes, we also support the following: ** ** sqlite -encoding ** ** Return the encoding used by LIKE and GLOB operators. Choices ** are UTF-8 and iso8859. ** ** sqlite -version ** ** Return the version number of the SQLite library. ** ** sqlite -tcl-uses-utf ** ** Return "1" if compiled with a Tcl uses UTF-8. Return "0" if ** not. Used by tests to make sure the library was compiled ** correctly. */ static int DbMain(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ int mode; SqliteDb *p; void *pKey = 0; int nKey = 0; const char *zArg; char *zErrMsg; const char *zFile; char zBuf[80]; if( objc==2 ){ zArg = Tcl_GetStringFromObj(objv[1], 0); if( strcmp(zArg,"-encoding")==0 ){ Tcl_AppendResult(interp,sqlite_encoding,0); return TCL_OK; } if( strcmp(zArg,"-version")==0 ){ Tcl_AppendResult(interp,sqlite_version,0); return TCL_OK; } if( strcmp(zArg,"-has-codec")==0 ){ #ifdef SQLITE_HAS_CODEC Tcl_AppendResult(interp,"1",0); #else Tcl_AppendResult(interp,"0",0); #endif return TCL_OK; } if( strcmp(zArg,"-tcl-uses-utf")==0 ){ #ifdef TCL_UTF_MAX Tcl_AppendResult(interp,"1",0); #else Tcl_AppendResult(interp,"0",0); #endif return TCL_OK; } } if( objc==5 || objc==6 ){ zArg = Tcl_GetStringFromObj(objv[objc-2], 0); if( strcmp(zArg,"-key")==0 ){ pKey = Tcl_GetByteArrayFromObj(objv[objc-1], &nKey); objc -= 2; } } if( objc!=3 && objc!=4 ){ Tcl_WrongNumArgs(interp, 1, objv, #ifdef SQLITE_HAS_CODEC "HANDLE FILENAME ?-key CODEC-KEY?" #else "HANDLE FILENAME ?MODE?" #endif ); return TCL_ERROR; } if( objc==3 ){ mode = 0666; }else if( Tcl_GetIntFromObj(interp, objv[3], &mode)!=TCL_OK ){ return TCL_ERROR; } zErrMsg = 0; p = (SqliteDb*)Tcl_Alloc( sizeof(*p) ); if( p==0 ){ Tcl_SetResult(interp, "malloc failed", TCL_STATIC); return TCL_ERROR; } memset(p, 0, sizeof(*p)); zFile = Tcl_GetStringFromObj(objv[2], 0); #ifdef SQLITE_HAS_CODEC p->db = sqlite_open_encrypted(zFile, pKey, nKey, 0, &zErrMsg); #else p->db = sqlite_open(zFile, mode, &zErrMsg); #endif if( p->db==0 ){ Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE); Tcl_Free((char*)p); free(zErrMsg); return TCL_ERROR; } zArg = Tcl_GetStringFromObj(objv[1], 0); Tcl_CreateObjCommand(interp, zArg, DbObjCmd, (char*)p, DbDeleteCmd); /* The return value is the value of the sqlite* pointer */ sprintf(zBuf, "%p", p->db); if( strncmp(zBuf,"0x",2) ){ sprintf(zBuf, "0x%p", p->db); } Tcl_AppendResult(interp, zBuf, 0); /* If compiled with SQLITE_TEST turned on, then register the "md5sum" ** SQL function. */ #ifdef SQLITE_TEST { extern void Md5_Register(sqlite*); Md5_Register(p->db); } #endif return TCL_OK; }
int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) { int rc = -1; c_strlist_t *result = NULL; sqlite3 *db = NULL; if( !ctx ) { return -1; } if (ctx->statedb.db) { CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: DB already open"); ctx->status_code = CSYNC_STATUS_PARAM_ERROR; return -1; } ctx->statedb.lastReturnValue = SQLITE_OK; /* Openthe database */ if (sqlite_open(statedb, &db) != SQLITE_OK) { const char *errmsg= sqlite3_errmsg(ctx->statedb.db); CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: Failed to sqlite3 open statedb - bail out: %s.", errmsg ? errmsg : "<no sqlite3 errormsg>"); rc = -1; ctx->status_code = CSYNC_STATUS_STATEDB_LOAD_ERROR; goto out; } if (_csync_check_db_integrity(db) != 0) { const char *errmsg= sqlite3_errmsg(db); CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: sqlite3 integrity check failed - bail out: %s.", errmsg ? errmsg : "<no sqlite3 errormsg>"); rc = -1; ctx->status_code = CSYNC_STATUS_STATEDB_CORRUPTED; goto out; } if (_csync_statedb_is_empty(db)) { CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb contents doesn't exist"); csync_set_statedb_exists(ctx, 0); } else { csync_set_statedb_exists(ctx, 1); } /* Print out the version */ // result = csync_statedb_query(db, "SELECT sqlite_version();"); if (result && result->count >= 1) { CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "sqlite3 version \"%s\"", *result->vector); } c_strlist_destroy(result); /* optimization for speeding up SQLite */ result = csync_statedb_query(db, "PRAGMA synchronous = NORMAL;"); c_strlist_destroy(result); result = csync_statedb_query(db, "PRAGMA case_sensitive_like = ON;"); c_strlist_destroy(result); /* set a busy handler with 5 seconds timeout */ sqlite3_busy_timeout(db, 5000); #ifndef NDEBUG sqlite3_profile(db, sqlite_profile, 0 ); #endif *pdb = db; CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "Success"); return 0; out: sqlite3_close(db); return rc; }