static void linphone_message_storage_activate_debug(sqlite3* db, bool_t debug){
if( debug ){
sqlite3_profile(db, _linphone_message_storage_profile, NULL );
} else {
sqlite3_profile(db, NULL, NULL );
}
}
void connection::trace( bool __trace ) {
_trace = __trace;
if( _trace ) {
sqlite3_profile( db, profiling_callback, NULL );
} else {
sqlite3_profile( db, NULL, NULL );
}
}
/* public native void close(); */
static void dbclose(JNIEnv* env, jobject object)
{
sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);
if (handle != NULL) {
// release the memory associated with the traceFuncArg in enableSqlTracing function
void *traceFuncArg = sqlite3_trace(handle, &sqlTrace, NULL);
if (traceFuncArg != NULL) {
free(traceFuncArg);
}
// release the memory associated with the traceFuncArg in enableSqlProfiling function
traceFuncArg = sqlite3_profile(handle, &sqlProfile, NULL);
if (traceFuncArg != NULL) {
free(traceFuncArg);
}
LOGV("Closing database: handle=%p\n", handle);
int result = sqlite3_close(handle);
if (result == SQLITE_OK) {
LOGV("Closed %p\n", handle);
env->SetIntField(object, offset_db_handle, 0);
} else {
// This can happen if sub-objects aren't closed first. Make sure the caller knows.
throw_sqlite3_exception(env, handle);
LOGE("sqlite3_close(%p) failed: %d\n", handle, result);
}
}
}
int sqlcipher_cipher_profile(sqlite3 *db, const char *destination){
FILE *f;
if(sqlite3StrICmp(destination, "stdout") == 0){
f = stdout;
}else if(sqlite3StrICmp(destination, "stderr") == 0){
f = stderr;
}else if(sqlite3StrICmp(destination, "off") == 0){
f = 0;
}else{
#if defined(_WIN32) && (__STDC_VERSION__ > 199901L) || defined(SQLITE_OS_WINRT)
if(fopen_s(&f, destination, "a") != 0){
#else
f = fopen(destination, "a");
if(f == 0){
#endif
return SQLITE_ERROR;
}
}
sqlite3_profile(db, sqlcipher_profile_callback, f);
return SQLITE_OK;
}
static void sqlcipher_profile_callback(void *file, const char *sql, sqlite3_uint64 run_time){
FILE *f = (FILE*)file;
double elapsed = run_time/1000000.0;
if(f) fprintf(f, "Elapsed time:%.3f ms - %s\n", elapsed, sql);
}
ULONG
SqlRegisterProfileCallback(
__in PSQL_DATABASE Database,
__in SQL_PROFILE_CALLBACK ProfileCallback,
__in PVOID Context
)
{
sqlite3_profile(Database->SqlHandle, ProfileCallback, Context);
return SQLITE_OK;
}
int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
int rc = -1;
int check_rc = -1;
c_strlist_t *result = NULL;
sqlite3 *db = NULL;
if( !ctx ) {
return -1;
}
/* csync_statedb_check tries to open the statedb and creates it in case
* its not there.
*/
check_rc = _csync_statedb_check(statedb);
if (check_rc < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: checking csync database failed - bail out.");
rc = -1;
goto out;
}
/* Open or create the temporary database */
if (sqlite3_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;
goto out;
}
/* If check_rc == 1 the database is new and empty as a result. */
if ((check_rc == 1) || _csync_statedb_is_empty(db)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb doesn't exist");
csync_set_statedb_exists(ctx, 0);
} else {
csync_set_statedb_exists(ctx, 1);
}
/* optimization for speeding up SQLite */
result = csync_statedb_query(db, "PRAGMA synchronous = FULL;");
c_strlist_destroy(result);
result = csync_statedb_query(db, "PRAGMA case_sensitive_like = ON;");
c_strlist_destroy(result);
#ifndef NDEBUG
sqlite3_profile(db, sqlite_profile, 0 );
#endif
*pdb = db;
return 0;
out:
sqlite3_close(db);
return rc;
}
int sqlcipher_cipher_profile(sqlite3 *db, const char *destination){
FILE *f;
if( strcmp(destination,"stdout")==0 ){
f = stdout;
}else if( strcmp(destination, "stderr")==0 ){
f = stderr;
}else if( strcmp(destination, "off")==0 ){
f = 0;
}else{
f = fopen(destination, "wb");
if( f==0 ){
return SQLITE_ERROR;
}
}
sqlite3_profile(db, sqlcipher_profile_callback, f);
return SQLITE_OK;
}
/* public native void enableSqlProfiling(); */
static void enableSqlProfiling(JNIEnv* env, jobject object, jstring databaseName, jshort connType)
{
sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);
sqlite3_profile(handle, &sqlProfile, (void *)getDatabaseName(env, handle, databaseName,
connType));
}
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;
}
static jlong nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlags,
jstring labelStr, jboolean enableTrace, jboolean enableProfile) {
int sqliteFlags;
if (openFlags & SQLiteConnection::CREATE_IF_NECESSARY) {
sqliteFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
} else if (openFlags & SQLiteConnection::OPEN_READONLY) {
sqliteFlags = SQLITE_OPEN_READONLY;
} else {
sqliteFlags = SQLITE_OPEN_READWRITE;
}
const char* pathChars = env->GetStringUTFChars(pathStr, NULL);
String8 path(pathChars);
env->ReleaseStringUTFChars(pathStr, pathChars);
const char* labelChars = env->GetStringUTFChars(labelStr, NULL);
String8 label(labelChars);
env->ReleaseStringUTFChars(labelStr, labelChars);
sqlite3* db;
int err = sqlite3_open_v2(path.string(), &db, sqliteFlags, NULL);
if (err != SQLITE_OK) {
throw_sqlite3_exception_errcode(env, err, "Could not open database");
return 0;
}
// Check that the database is really read/write when that is what we asked for.
if ((sqliteFlags & SQLITE_OPEN_READWRITE) && sqlite3_db_readonly(db, NULL)) {
throw_sqlite3_exception(env, db, "Could not open the database in read/write mode.");
sqlite3_close(db);
return 0;
}
// Set the default busy handler to retry automatically before returning SQLITE_BUSY.
err = sqlite3_busy_timeout(db, BUSY_TIMEOUT_MS);
if (err != SQLITE_OK) {
throw_sqlite3_exception(env, db, "Could not set busy timeout");
sqlite3_close(db);
return 0;
}
// Register custom Android functions.
err = register_android_functions(db, UTF16_STORAGE);
if (err) {
throw_sqlite3_exception(env, db, "Could not register Android SQL functions.");
sqlite3_close(db);
return 0;
}
// Create wrapper object.
SQLiteConnection* connection = new SQLiteConnection(db, openFlags, path, label);
// Enable tracing and profiling if requested.
if (enableTrace) {
sqlite3_trace(db, &sqliteTraceCallback, connection);
}
if (enableProfile) {
sqlite3_profile(db, &sqliteProfileCallback, connection);
}
ALOGV("Opened connection %p with label '%s'", db, label.string());
return reinterpret_cast<jlong>(connection);
}
svn_error_t *
svn_sqlite__open(svn_sqlite__db_t **db, const char *path,
svn_sqlite__mode_t mode, const char * const statements[],
int latest_schema, const char * const *upgrade_sql,
apr_pool_t *result_pool, apr_pool_t *scratch_pool)
{
SVN_ERR(svn_atomic__init_once(&sqlite_init_state,
init_sqlite, NULL, scratch_pool));
*db = apr_pcalloc(result_pool, sizeof(**db));
SVN_ERR(internal_open(&(*db)->db3, path, mode, scratch_pool));
#ifdef SQLITE3_DEBUG
sqlite3_trace((*db)->db3, sqlite_tracer, (*db)->db3);
#endif
#ifdef SQLITE3_PROFILE
sqlite3_profile((*db)->db3, sqlite_profiler, (*db)->db3);
#endif
/* Work around a bug in SQLite 3.7.7. The bug was fixed in SQLite 3.7.7.1.
See:
Date: Sun, 26 Jun 2011 18:52:14 -0400
From: Richard Hipp <*****@*****.**>
To: General Discussion of SQLite Database <*****@*****.**>
Cc: [email protected]
Subject: Re: [sqlite] PRAGMA bug in 3.7.7 (but fine in 3.7.6.3)
Message-ID: <*****@*****.**>
*/
{
int ignored_err = SQLITE_OK;
#if !SQLITE_VERSION_AT_LEAST(3,7,8) && defined(SQLITE_SCHEMA)
if (!strcmp(sqlite3_libversion(), "3.7.7"))
ignored_err = SQLITE_SCHEMA;
#endif
SVN_ERR(exec_sql2(*db, "PRAGMA case_sensitive_like=1;", ignored_err));
}
SVN_ERR(exec_sql(*db,
/* Disable synchronization to disable the explicit disk flushes
that make Sqlite up to 50 times slower; especially on small
transactions.
This removes some stability guarantees on specific hardware
and power failures, but still guarantees atomic commits on
application crashes. With our dependency on external data
like pristine files (Wc) and revision files (repository),
we can't keep up these additional guarantees anyway.
### Maybe switch to NORMAL(1) when we use larger transaction
scopes */
"PRAGMA synchronous=OFF;"
/* Enable recursive triggers so that a user trigger will fire
in the deletion phase of an INSERT OR REPLACE statement.
Requires SQLite >= 3.6.18 */
"PRAGMA recursive_triggers=ON;"));
#if SQLITE_VERSION_AT_LEAST(3,6,19) && defined(SVN_DEBUG)
/* When running in debug mode, enable the checking of foreign key
constraints. This has possible performance implications, so we don't
bother to do it for production...for now. */
SVN_ERR(exec_sql(*db, "PRAGMA foreign_keys=ON;"));
#endif
/* Store temporary tables in RAM instead of in temporary files, but don't
fail on this if this option is disabled in the sqlite compilation by
setting SQLITE_TEMP_STORE to 0 (always to disk) */
svn_error_clear(exec_sql(*db, "PRAGMA temp_store = MEMORY;"));
/* Validate the schema, upgrading if necessary. */
if (upgrade_sql != NULL)
SVN_ERR(check_format(*db, latest_schema, upgrade_sql, scratch_pool));
/* Store the provided statements. */
if (statements)
{
(*db)->statement_strings = statements;
(*db)->nbr_statements = 0;
while (*statements != NULL)
{
statements++;
(*db)->nbr_statements++;
}
(*db)->prepared_stmts = apr_pcalloc(result_pool, (*db)->nbr_statements
* sizeof(svn_sqlite__stmt_t *));
}
else
(*db)->nbr_statements = 0;
(*db)->state_pool = result_pool;
apr_pool_cleanup_register(result_pool, *db, close_apr, apr_pool_cleanup_null);
return SVN_NO_ERROR;
}
void DB::StartProfiling()
{
Poco::ScopedLock<Poco::FastMutex> guard(m_profilemutex);
sqlite3_profile(m_db,DB::ProfileCallback,this);
m_profiling=true;
}
DLL_FUNCTION(void*) BU_SQLite_Profile(sqlite3* db,
void(*xProfile)(void*, const char*, sqlite3_uint64),
void* param) {
#pragma comment(linker, "/EXPORT:BU_SQLite_Profile=_BU_SQLite_Profile@12")
return sqlite3_profile(db, xProfile, param);
}
int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
int rc = -1;
int check_rc = -1;
c_strlist_t *result = NULL;
char *statedb_tmp = NULL;
sqlite3 *db = NULL;
/* csync_statedb_check tries to open the statedb and creates it in case
* its not there.
*/
check_rc = _csync_statedb_check(statedb);
if (check_rc < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: checking csync database failed - bail out.");
rc = -1;
goto out;
}
/*
* We want a two phase commit for the jounal, so we create a temporary copy
* of the database.
* The intention is that if something goes wrong we will not loose the
* statedb.
*/
rc = asprintf(&statedb_tmp, "%s.ctmp", statedb);
if (rc < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: could not create statedb name - bail out.");
rc = -1;
goto out;
}
if (c_copy(statedb, statedb_tmp, 0644) < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: Failed to copy statedb -> statedb_tmp - bail out.");
rc = -1;
goto out;
}
_csync_win32_hide_file( statedb_tmp );
/* Open or create the temporary database */
if (sqlite3_open(statedb_tmp, &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;
goto out;
}
SAFE_FREE(statedb_tmp);
/* If check_rc == 1 the database is new and empty as a result. */
if ((check_rc == 1) || _csync_statedb_is_empty(db)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb doesn't exist");
csync_set_statedb_exists(ctx, 0);
} else {
csync_set_statedb_exists(ctx, 1);
}
/* optimization for speeding up SQLite */
result = csync_statedb_query(db, "PRAGMA synchronous = FULL;");
c_strlist_destroy(result);
result = csync_statedb_query(db, "PRAGMA case_sensitive_like = ON;");
c_strlist_destroy(result);
#ifndef NDEBUG
sqlite3_profile(db, sqlite_profile, 0 );
#endif
*pdb = db;
return 0;
out:
sqlite3_close(db);
SAFE_FREE(statedb_tmp);
return rc;
}
svn_error_t *
svn_sqlite__open(svn_sqlite__db_t **db, const char *path,
svn_sqlite__mode_t mode, const char * const statements[],
int unused1, const char * const *unused2,
apr_int32_t timeout,
apr_pool_t *result_pool, apr_pool_t *scratch_pool)
{
SVN_ERR(svn_atomic__init_once(&sqlite_init_state,
init_sqlite, NULL, scratch_pool));
*db = apr_pcalloc(result_pool, sizeof(**db));
SVN_ERR(internal_open(*db, path, mode, timeout, scratch_pool));
#if SQLITE_VERSION_NUMBER >= 3008000 && SQLITE_VERSION_NUMBER < 3009000
/* disable SQLITE_ENABLE_STAT3/4 from 3.8.1 - 3.8.3 (but not 3.8.3.1+)
* to prevent using it when it's buggy.
* See: https://www.sqlite.org/src/info/4c86b126f2 */
if (sqlite3_libversion_number() > 3008000 &&
sqlite3_libversion_number() < 3008004 &&
strcmp(sqlite3_sourceid(),"2014-02-11")<0)
{
sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, (*db)->db3, 0x800);
}
#endif
#ifdef SVN_UNICODE_NORMALIZATION_FIXES
/* Create extension buffers with space for 200 UCS-4 characters. */
svn_membuf__create(&(*db)->sqlext_buf1, 800, result_pool);
svn_membuf__create(&(*db)->sqlext_buf2, 800, result_pool);
svn_membuf__create(&(*db)->sqlext_buf3, 800, result_pool);
/* Register collation and LIKE and GLOB operator replacements. */
SQLITE_ERR_CLOSE(sqlite3_create_collation((*db)->db3,
"svn-ucs-nfd", SQLITE_UTF8,
*db, collate_ucs_nfd),
db, scratch_pool);
/* ### Is it really necessary to override these functions?
I would assume the default implementation to be collation agnostic?
And otherwise our implementation should be...
The default implementation is in some cases index backed, while our
implementation can't be. With an index based on the collation it could
be. */
SQLITE_ERR_CLOSE(sqlite3_create_function((*db)->db3, "glob", 2,
SQLITE_UTF8 | SQLITE_DETERMINISTIC,
*db, glob_ucs_nfd, NULL, NULL),
db, scratch_pool);
SQLITE_ERR_CLOSE(sqlite3_create_function((*db)->db3, "like", 2,
SQLITE_UTF8 | SQLITE_DETERMINISTIC,
*db, like_ucs_nfd, NULL, NULL),
db, scratch_pool);
SQLITE_ERR_CLOSE(sqlite3_create_function((*db)->db3, "like", 3,
SQLITE_UTF8 | SQLITE_DETERMINISTIC,
*db, like_ucs_nfd, NULL, NULL),
db, scratch_pool);
#endif /* SVN_UNICODE_NORMALIZATION_FIXES */
#ifdef SQLITE3_DEBUG
sqlite3_trace((*db)->db3, sqlite_tracer, (*db)->db3);
#endif
#ifdef SQLITE3_PROFILE
sqlite3_profile((*db)->db3, sqlite_profiler, (*db)->db3);
#endif
SVN_ERR_CLOSE(exec_sql(*db,
/* The default behavior of the LIKE operator is to ignore case
for ASCII characters. Hence, by default 'a' LIKE 'A' is true.
The case_sensitive_like pragma installs a new application-
defined LIKE function that is either case sensitive or
insensitive depending on the value of the case_sensitive_like
pragma. */
"PRAGMA case_sensitive_like=1;"
/* Disable synchronization to disable the explicit disk flushes
that make Sqlite up to 50 times slower; especially on small
transactions.
This removes some stability guarantees on specific hardware
and power failures, but still guarantees atomic commits on
application crashes. With our dependency on external data
like pristine files (Wc) and revision files (repository),
we can't keep up these additional guarantees anyway.
### Maybe switch to NORMAL(1) when we use larger transaction
scopes */
"PRAGMA synchronous=OFF;"
/* Enable recursive triggers so that a user trigger will fire
in the deletion phase of an INSERT OR REPLACE statement.
Requires SQLite >= 3.6.18 */
"PRAGMA recursive_triggers=ON;"
/* Enforce current Sqlite default behavior. Some distributions
might change the Sqlite defaults without realizing how this
affects application(read: Subversion) performance/behavior. */
"PRAGMA foreign_keys=OFF;" /* SQLITE_DEFAULT_FOREIGN_KEYS*/
"PRAGMA locking_mode = NORMAL;" /* SQLITE_DEFAULT_LOCKING_MODE */
/* Testing shows TRUNCATE is faster than DELETE on Windows. */
"PRAGMA journal_mode = TRUNCATE;"
),
*db);
#if defined(SVN_DEBUG)
/* When running in debug mode, enable the checking of foreign key
constraints. This has possible performance implications, so we don't
bother to do it for production...for now. */
SVN_ERR_CLOSE(exec_sql(*db, "PRAGMA foreign_keys=ON;"),
*db);
#endif
#ifdef SVN_SQLITE_REVERSE_UNORDERED_SELECTS
/* When enabled, this PRAGMA causes SELECT statements without an ORDER BY
clause to emit their results in the reverse order of what they normally
would. This can help detecting invalid assumptions about the result
order.*/
SVN_ERR_CLOSE(exec_sql(*db, "PRAGMA reverse_unordered_selects=ON;"),
*db);
#endif
/* Store temporary tables in RAM instead of in temporary files, but don't
fail on this if this option is disabled in the sqlite compilation by
setting SQLITE_TEMP_STORE to 0 (always to disk) */
svn_error_clear(exec_sql(*db, "PRAGMA temp_store = MEMORY;"));
/* Store the provided statements. */
if (statements)
{
(*db)->statement_strings = statements;
(*db)->nbr_statements = 0;
while (*statements != NULL)
{
statements++;
(*db)->nbr_statements++;
}
(*db)->prepared_stmts = apr_pcalloc(
result_pool,
((*db)->nbr_statements + STMT_INTERNAL_LAST)
* sizeof(svn_sqlite__stmt_t *));
}
else
{
(*db)->nbr_statements = 0;
(*db)->prepared_stmts = apr_pcalloc(result_pool,
(0 + STMT_INTERNAL_LAST)
* sizeof(svn_sqlite__stmt_t *));
}
(*db)->state_pool = result_pool;
apr_pool_cleanup_register(result_pool, *db, close_apr, apr_pool_cleanup_null);
return SVN_NO_ERROR;
}
