int SQLiteStatement::prepare() { ASSERT(!m_isPrepared); MutexLocker databaseLock(m_database.databaseMutex()); if (m_database.isInterrupted()) return SQLITE_INTERRUPT; const void* tail = 0; LOG(SQLDatabase, "SQL - prepare - %s", m_query.ascii().data()); String strippedQuery = m_query.stripWhiteSpace(); const UChar* nullTermed = strippedQuery.deprecatedCharactersWithNullTermination(); int error = sqlite3_prepare16_v2(m_database.sqlite3Handle(), nullTermed, -1, &m_statement, &tail); // Starting with version 3.6.16, sqlite has a patch (http://www.sqlite.org/src/ci/256ec3c6af) // that should make sure sqlite3_prepare16_v2 doesn't return a SQLITE_SCHEMA error. // If we're using an older sqlite version, try to emulate the patch. if (error == SQLITE_SCHEMA) { sqlite3_finalize(m_statement); error = sqlite3_prepare16_v2(m_database.sqlite3Handle(), m_query.deprecatedCharactersWithNullTermination(), -1, &m_statement, &tail); } if (error != SQLITE_OK) LOG(SQLDatabase, "sqlite3_prepare16 failed (%i)\n%s\n%s", error, m_query.ascii().data(), sqlite3_errmsg(m_database.sqlite3Handle())); const UChar* ch = static_cast<const UChar*>(tail); if (ch && *ch) error = SQLITE_ERROR; #ifndef NDEBUG m_isPrepared = error == SQLITE_OK; #endif return error; }
object sqlite3::compile(flusspferd::string sql_in, value bind ) { local_root_scope scope; size_t n_bytes = sql_in.length() * 2; sqlite3_stmt * sth = 0; js_char16_t * tail = 0; // uncompiled part of the sql (when multiple stmts) if (sqlite3_prepare16_v2(db, sql_in.data(), n_bytes, &sth, (const void**)&tail) != SQLITE_OK) { raise_sqlite_error(db); } object cursor = create<sqlite3_cursor>(fusion::make_vector(sth)); string tail_str; if (tail) { tail_str = string(tail); } string sql = sql_in.substr( 0, sql_in.size() - tail_str.size() ); cursor.define_property("sql", sql); cursor.define_property("tail", tail_str); if ( !bind.is_undefined_or_null() ) { cursor.call("bind", bind ); } return cursor; }
sqlite3_command::sqlite3_command(sqlite3_connection &con, const wchar_t *sql) : con(con),refs(0) { const wchar_t *tail=NULL; if(sqlite3_prepare16_v2(con.db, sql, -1, &this->stmt, (const void**)&tail)!=SQLITE_OK) throw database_error(con); this->argc=sqlite3_column_count(this->stmt); }
static jlong nativePrepareStatement(JNIEnv* env, jclass clazz, jlong connectionPtr, jstring sqlString) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); jsize sqlLength = env->GetStringLength(sqlString); const jchar* sql = env->GetStringCritical(sqlString, NULL); sqlite3_stmt* statement; int err = sqlite3_prepare16_v2(connection->db, sql, sqlLength * sizeof(jchar), &statement, NULL); env->ReleaseStringCritical(sqlString, sql); if (err != SQLITE_OK) { // Error messages like 'near ")": syntax error' are not // always helpful enough, so construct an error string that // includes the query itself. const char *query = env->GetStringUTFChars(sqlString, NULL); char *message = (char*) malloc(strlen(query) + 50); if (message) { strcpy(message, ", while compiling: "); // less than 50 chars strcat(message, query); } env->ReleaseStringUTFChars(sqlString, query); throw_sqlite3_exception(env, connection->db, message); free(message); return 0; } ALOGV("Prepared statement %p on connection %p", statement, connection->db); return reinterpret_cast<jlong>(statement); }
sqlite3_command::sqlite3_command(sqlite3_connection &con, const std::wstring &sql) : con(con),refs(0) { const wchar_t *tail=NULL; if(sqlite3_prepare16_v2(con.db, sql.data(), (int)sql.length()*2, &this->stmt, (const void**)&tail)!=SQLITE_OK) throw database_error(con); this->argc=sqlite3_column_count(this->stmt); }
//This function attempts to execute sqlite3_prepare_v2() or sqlite3_prepare16_v2() in an "out of memory loop". //If the prepare call fails, the statement handle is expected to be NULL. void StmtHandleTest(TStmtType aStmtType) { TEST(TheSqliteDb != NULL); for(TInt failingAllocationNo=1;;++failingAllocationNo) { __UHEAP_SETFAIL(RHeap::EFailNext, failingAllocationNo); sqlite3_stmt* stmt = NULL; TInt err = SQLITE_NOMEM; if(aStmtType == EStmt8) { _LIT8(KSelectSqlZ,"SELECT * FROM A\x0"); err = sqlite3_prepare_v2(TheSqliteDb, (const char*)(KSelectSqlZ().Ptr()), -1, &stmt, NULL); } else { _LIT(KSelectSqlZ,"SELECT * FROM A\x0"); err = sqlite3_prepare16_v2(TheSqliteDb, (const char*)(KSelectSqlZ().Ptr()), -1, &stmt, NULL); } __UHEAP_SETFAIL(RHeap::ENone, 0); if(err != SQLITE_OK) {//The statement handle should be NULL if err is not SQLITE_OK TEST(!stmt); } else { TEST(stmt != NULL); sqlite3_finalize(stmt); break; } } }
bool SQLiteResult::prepare(const QString &query) { if (!driver() || !driver()->isOpen() || driver()->isOpenError()) return false; d->cleanup(); setSelect(false); const void *pzTail = NULL; #if (SQLITE_VERSION_NUMBER >= 3003011) int res = sqlite3_prepare16_v2(d->access, query.constData(), (query.size() + 1) * sizeof(QChar), &d->stmt, &pzTail); #else int res = sqlite3_prepare16(d->access, query.constData(), (query.size() + 1) * sizeof(QChar), &d->stmt, &pzTail); #endif if (res != SQLITE_OK) { #if defined(SQLITEDRIVER_DEBUG) trace(NULL, query.toUtf8().constData()); #endif setLastError(qMakeError(d->access, QCoreApplication::translate("SQLiteResult", "Unable to execute statement"), QSqlError::StatementError, res)); d->finalize(); return false; } else if (pzTail && !stringFromUnicode(reinterpret_cast<const QChar *>(pzTail)).trimmed().isEmpty()) { setLastError(qMakeError(d->access, QCoreApplication::translate("SQLiteResult", "Unable to execute multiple statements at a time"), QSqlError::StatementError, SQLITE_MISUSE)); d->finalize(); return false; } return true; }
bool QSpatiaLiteResult::prepare(const QString &query) { if (!driver() || !driver()->isOpen() || driver()->isOpenError()) return false; d->cleanup(); setSelect(false); const void *pzTail = NULL; #if (SQLITE_VERSION_NUMBER >= 3003011) int res = sqlite3_prepare16_v2(d->access, query.constData(), (query.size() + 1) * sizeof(QChar), &d->stmt, &pzTail); #else int res = sqlite3_prepare16(d->access, query.constData(), (query.size() + 1) * sizeof(QChar), &d->stmt, &pzTail); #endif if (res != SQLITE_OK) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSpatiaLiteResult", "Unable to execute statement"), QSqlError::StatementError, res)); d->finalize(); return false; } else if (pzTail && !QString::fromUtf16( (const ushort *) pzTail ).trimmed().isEmpty()) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSpatiaLiteResult", "Unable to execute multiple statements at a time"), QSqlError::StatementError, SQLITE_MISUSE)); d->finalize(); return false; } return true; }
/* * Class: com_sabo_sqlite_SQLiteDatabase * Method: nativeExecute * Signature: (JLjava/lang/String;)I */ JNIEXPORT jint JNICALL Java_com_sabo_sqlite_SQLiteDatabase_nativeExecute (JNIEnv *env, jobject clazz, jlong connectionPtr, jstring sql) { const jchar *zSql; int nBytes; int rc; sqlite3 *pDb; sqlite3_stmt *pStmt; assert(sql != NULL && connectionPtr != 0); zSql = env->GetStringCritical(sql, NULL); nBytes = env->GetStringLength(sql) * 2; assert(zSql != NULL); pDb = (sqlite3 *)connectionPtr; rc = sqlite3_prepare16_v2(pDb, zSql, nBytes, &pStmt, NULL); env->ReleaseStringCritical(sql, zSql); if (rc != SQLITE_OK) { sqlite3_finalize(pStmt); return (jint)rc; } rc = sqlite3_step(pStmt); if (rc == SQLITE_DONE) rc = SQLITE_OK; sqlite3_finalize(pStmt); return (jint)rc; }
bool O2DatDB:: select(O2DatRec &out, const wchar_t *domain, const wchar_t *bbsname, const wchar_t *datname) { #if TRACE_SQL_EXEC_TIME stopwatch sw("select by domain bbsname datname"); #endif bool ret = true; sqlite3 *db = NULL; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); wchar_t *sql = L"select" COLUMNS L" from dat" L" where domain = ?" L" and bbsname = ?" L" and datname = ?;"; sqlite3_stmt *stmt = NULL; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; if (!bind(db, stmt, 1, domain)) goto error; if (!bind(db, stmt, 2, bbsname)) goto error; if (!bind(db, stmt, 3, datname)) goto error; err = sqlite3_step(stmt); if (err != SQLITE_ROW && err != SQLITE_DONE) goto error; if (err == SQLITE_DONE) ret = false; if (err == SQLITE_ROW) get_columns(stmt, out); sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return (ret); error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return false; }
SQLiteSTMT::SQLiteSTMT(sqlite3* db, const void* zSql, int nByte, const void** pzTail) { this->db = db; handle = 0; int ret; if ((ret = sqlite3_prepare16_v2(db, zSql, nByte, &handle, pzTail)) != SQLITE_OK || !handle) { Close(); throw ret; } }
size_t O2DatDB:: select(const wchar_t *sql, SQLResultList &out) { #if TRACE_SQL_EXEC_TIME stopwatch sw("select"); #endif wstrarray cols; sqlite3 *db = NULL; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); sqlite3_stmt *stmt = NULL; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; sqlite3_reset(stmt); err = sqlite3_step(stmt); if (err != SQLITE_ROW && err != SQLITE_DONE) goto error; if (out.empty()) { //一行目 cols.clear(); get_column_names(stmt, cols); out.push_back(cols); cols.clear(); get_columns(stmt, cols); out.push_back(cols); } while (sqlite3_step(stmt) == SQLITE_ROW) { //2行目以降 cols.clear(); get_columns(stmt, cols); out.push_back(cols); } sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return (out.size()); error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return (0); }
/** request : 'db -> sql:string -> 'result <doc>Executes the SQL request and returns its result</doc> **/ HL_PRIM sqlite_result *HL_NAME(request)(sqlite_database *db, vbyte *sql ) { sqlite_result *r; const char *tl; int i,j; r = (sqlite_result*)hl_gc_alloc_finalizer(sizeof(sqlite_result)); r->finalize = HL_NAME(finalize_result); r->db = db; if( sqlite3_prepare16_v2(db->db, sql, -1, &r->r, &tl) != SQLITE_OK ) { HL_NAME(error)(db->db, false); } if( *tl ) { sqlite3_finalize(r->r); hl_error("SQLite error: Cannot execute several SQL requests at the same time"); } r->ncols = sqlite3_column_count(r->r); r->names = (int*)hl_gc_alloc(sizeof(int)*r->ncols); r->bools = (int*)hl_gc_alloc(sizeof(int)*r->ncols); r->first = 1; r->done = 0; for(i=0;i<r->ncols;i++) { int id = hl_hash_gen((uchar*)sqlite3_column_name16(r->r,i), true); const char *dtype = sqlite3_column_decltype(r->r,i); for(j=0;j<i;j++) if( r->names[j] == id ) { if( strcmp(sqlite3_column_name16(r->r,i), sqlite3_column_name16(r->r,j)) == 0 ) { sqlite3_finalize(r->r); hl_buffer *b = hl_alloc_buffer(); hl_buffer_str(b, USTR("SQLite error: Same field is two times in the request: ")); hl_buffer_str(b, (uchar*)sql); hl_error_msg(hl_buffer_content(b, NULL)); } else { hl_buffer *b = hl_alloc_buffer(); hl_buffer_str(b, USTR("SQLite error: Same field ids for: ")); hl_buffer_str(b, sqlite3_column_name16(r->r,i)); hl_buffer_str(b, USTR(" and ")); hl_buffer_str(b, sqlite3_column_name16(r->r,j)); sqlite3_finalize(r->r); hl_error_msg(hl_buffer_content(b, NULL)); } } r->names[i] = id; r->bools[i] = dtype?(strcmp(dtype,"BOOL") == 0):0; } // changes in an update/delete if( db->last != NULL ) HL_NAME(finalize_request)(db->last, false); db->last = r; return db->last; }
bool O2DatDB:: select(O2DatRecList &out, time_t publish_tt, size_t limit) { #if TRACE_SQL_EXEC_TIME stopwatch sw("select lastpublish"); #endif sqlite3 *db = NULL; sqlite3_stmt *stmt = NULL; O2DatRec rec; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); wchar_t *sql = L"select" COLUMNS L" from dat" L" where lastpublish < ?" L" order by lastpublish" L" limit ?;"; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; if (!bind(db, stmt, 1, time(NULL)-publish_tt)) goto error; if (!bind(db, stmt, 2, limit)) goto error; while (sqlite3_step(stmt) == SQLITE_ROW) { get_columns(stmt, rec); out.push_back(rec); } sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return true; error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return false; }
static JSVAL sqlite_prepare16_v2(JSARGS args) { HandleScope scope; Local<External>wrap = Local<External>::Cast(args[0]); sqlite3 *db = (sqlite3 *)wrap->Value(); String::Utf8Value zSql(args[1]->ToString()); int nByte = args[2]->IntegerValue() ; sqlite3_stmt *stmt; if (!sqlite3_prepare16_v2(db, *zSql, nByte, &stmt, NULL)) { return scope.Close(String::New(sqlite3_errmsg(db))); } return scope.Close(External::New(stmt)); }
bool O2DatDB:: select(O2DatRecList &out, const wchar_t *domain, const wchar_t *bbsname) { #if TRACE_SQL_EXEC_TIME stopwatch sw("select domain bbsname order by datname"); #endif sqlite3 *db = NULL; sqlite3_stmt *stmt = NULL; O2DatRec rec; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); wchar_t *sql = L"select" COLUMNS L" from dat" L" where domain = ?" L" and bbsname = ?" L" order by datname;"; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; if (!bind(db, stmt, 1, domain)) goto error; if (!bind(db, stmt, 2, bbsname)) goto error; while (sqlite3_step(stmt) == SQLITE_ROW) { get_columns(stmt, rec); out.push_back(rec); } sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return true; error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return false; }
BOOL SQLiteCommand::SetCommandText(LPCTSTR lpSql) { #ifdef UNICODE if (sqlite3_prepare16_v2(m_pSqlite->m_db, lpSql, -1, &m_pStmt, NULL) != SQLITE_OK) #else if (sqlite3_prepare_v2(m_pSqlite->m_db, lpSql, -1, &m_pStmt, NULL) != SQLITE_OK) #endif { return FALSE; } return TRUE; }
int SQLiteStatement::prepare() { ASSERT(!m_isPrepared); const void* tail; LOG(SQLDatabase, "SQL - prepare - %s", m_query.ascii().data()); int error = sqlite3_prepare16_v2(m_database.sqlite3Handle(), m_query.charactersWithNullTermination(), -1, &m_statement, &tail); if (error != SQLITE_OK) LOG(SQLDatabase, "sqlite3_prepare16 failed (%i)\n%s\n%s", error, m_query.ascii().data(), sqlite3_errmsg(m_database.sqlite3Handle())); #ifndef NDEBUG m_isPrepared = error == SQLITE_OK; #endif return error; }
bool O2DatDB:: select(O2DatRec &out) { #if TRACE_SQL_EXEC_TIME stopwatch sw("select random 1"); #endif bool ret = true; sqlite3 *db = NULL; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); wchar_t *sql = L"select" COLUMNS L" from dat" L" order by random() limit 1;"; sqlite3_stmt *stmt = NULL; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; sqlite3_reset(stmt); err = sqlite3_step(stmt); if (err != SQLITE_ROW && err != SQLITE_DONE) goto error; if (err == SQLITE_DONE) ret = false; if (err == SQLITE_ROW) get_columns(stmt, out); sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return (ret); error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return false; }
uint64 O2DatDB:: select_datcount(wstrnummap &out) { #if TRACE_SQL_EXEC_TIME stopwatch sw("select datcount group by domain bbsname"); #endif sqlite3 *db = NULL; sqlite3_stmt *stmt = NULL; wstring domain_bbsname; uint64 total = 0; uint64 num; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); wchar_t *sql = L"select domain, bbsname, count(*) from dat group by domain, bbsname;"; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; while (sqlite3_step(stmt) == SQLITE_ROW) { domain_bbsname = (wchar_t*)sqlite3_column_text16(stmt, 0); domain_bbsname += L":"; domain_bbsname += (wchar_t*)sqlite3_column_text16(stmt, 1); num = sqlite3_column_int64(stmt, 2); out.insert(wstrnummap::value_type(domain_bbsname, num)); total += num; } sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return (total); error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return false; }
/* public native void native_execSQL(String sql); */ static void native_execSQL(JNIEnv* env, jobject object, jstring sqlString) { int err; int stepErr; sqlite3_stmt * statement = NULL; sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle); jchar const * sql = env->GetStringChars(sqlString, NULL); jsize sqlLen = env->GetStringLength(sqlString); if (sql == NULL || sqlLen == 0) { jniThrowException(env, "java/lang/IllegalArgumentException", "You must supply an SQL string"); return; } err = sqlite3_prepare16_v2(handle, sql, sqlLen * 2, &statement, NULL); env->ReleaseStringChars(sqlString, sql); if (err != SQLITE_OK) { char const * sql8 = env->GetStringUTFChars(sqlString, NULL); LOGE("Failure %d (%s) on %p when preparing '%s'.\n", err, sqlite3_errmsg(handle), handle, sql8); throw_sqlite3_exception(env, handle, sql8); env->ReleaseStringUTFChars(sqlString, sql8); return; } stepErr = sqlite3_step(statement); err = sqlite3_finalize(statement); if (stepErr != SQLITE_DONE) { if (stepErr == SQLITE_ROW) { throw_sqlite3_exception(env, "Queries cannot be performed using execSQL(), use query() instead."); } else { char const * sql8 = env->GetStringUTFChars(sqlString, NULL); LOGE("Failure %d (%s) on %p when executing '%s'\n", err, sqlite3_errmsg(handle), handle, sql8); throw_sqlite3_exception(env, handle, sql8); env->ReleaseStringUTFChars(sqlString, sql8); } } else #ifndef DB_LOG_STATEMENTS IF_LOGV() #endif { char const * sql8 = env->GetStringUTFChars(sqlString, NULL); LOGV("Success on %p when executing '%s'\n", handle, sql8); env->ReleaseStringUTFChars(sqlString, sql8); } }
uint64 O2DatDB:: select_publishcount(time_t publish_tt) { #if TRACE_SQL_EXEC_TIME stopwatch sw("select datcount by lastpublish"); #endif sqlite3 *db = NULL; sqlite3_stmt *stmt = NULL; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); wchar_t *sql = L"select count(*) from dat where lastpublish > ?;"; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; if (!bind(db, stmt, 1, time(NULL)-publish_tt)) goto error; err = sqlite3_step(stmt); if (err != SQLITE_ROW && err != SQLITE_DONE) goto error; uint64 count = sqlite3_column_int64(stmt,0); sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return (count); error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return (0); }
// 查询 SQLiteDataReader SQLite::ExcuteQuery(LPCTSTR lpSql) { if (lpSql == NULL) { return FALSE; } sqlite3_stmt* stmt; #ifdef UNICODE if (sqlite3_prepare16_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK) #else if (sqlite3_prepare_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK) #endif { return FALSE; } return SQLiteDataReader(stmt); }
bool O2DatDB:: select(O2DatRecList &out) { #if TRACE_SQL_EXEC_TIME stopwatch sw("select all"); #endif sqlite3 *db = NULL; sqlite3_stmt *stmt = NULL; O2DatRec rec; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); wchar_t *sql = L"select" COLUMNS L" from dat;"; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; while (sqlite3_step(stmt) == SQLITE_ROW) { get_columns(stmt, rec); out.push_back(rec); } sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return true; error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return false; }
bool O2DatDB:: remove(const hashT &hash) { #if TRACE_SQL_EXEC_TIME stopwatch sw("remove"); #endif sqlite3 *db = NULL; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); wchar_t *sql = L"delete from dat where hash = ?;"; sqlite3_stmt *stmt = NULL; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; if (!bind(db, stmt, 1, hash)) goto error; err = sqlite3_step(stmt); if (err != SQLITE_ROW && err != SQLITE_DONE) goto error; sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return true; error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return false; }
bool O2DatDB:: update_lastpublish(const hashT &hash) { sqlite3 *db = NULL; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); wchar_t *sql = L"update or replace dat" L" set lastpublish = ?" L" where hash = ?;"; sqlite3_stmt *stmt = NULL; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; if (!bind(db, stmt, 1, time(NULL))) goto error; if (!bind(db, stmt, 2, hash)) goto error; err = sqlite3_step(stmt); if (err != SQLITE_ROW && err != SQLITE_DONE) goto error; sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return true; error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return false; }
BOOL SQLite::ExcuteNonQuery(LPCTSTR lpSql) { if (lpSql == NULL) { return FALSE; } sqlite3_stmt* stmt; #ifdef UNICODE if (sqlite3_prepare16_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK) #else if (sqlite3_prepare_v2(m_db, lpSql, -1, &stmt, NULL) != SQLITE_OK) #endif { return FALSE; } sqlite3_step(stmt); return (sqlite3_finalize(stmt) == SQLITE_OK) ? TRUE : FALSE; }
uint64 O2DatDB:: select_totaldisksize(void) { #if TRACE_SQL_EXEC_TIME stopwatch sw("select totakdisksize"); #endif sqlite3 *db = NULL; sqlite3_stmt *stmt = NULL; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); wchar_t *sql = L"select sum(disksize) from dat;"; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; err = sqlite3_step(stmt); if (err != SQLITE_ROW && err != SQLITE_DONE) goto error; uint64 totalsize = sqlite3_column_int64(stmt,0); sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return (totalsize); error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return (0); }
/* * Class: com_sabo_sqlite_SQLiteDatabase_SQLiteQuery * Method: nativeStatement * Signature: (JLjava/lang/String;)J */ JNIEXPORT jlong JNICALL Java_com_sabo_sqlite_SQLiteDatabase_00024SQLiteQuery_nativeStatement (JNIEnv *env, jobject clazz, jlong connectionPtr, jstring sql) { const jchar *zSql; int rc; int nBytes; sqlite3 *pDb; sqlite3_stmt *pStmt; assert(connectionPtr != 0); assert(sql != NULL); pDb = (sqlite3 *)connectionPtr; zSql = env->GetStringCritical(sql, NULL); nBytes = env->GetStringLength(sql) * 2; assert(zSql != NULL); rc = sqlite3_prepare16_v2(pDb, zSql, nBytes, &pStmt, NULL); env->ReleaseStringCritical(sql, zSql); if (rc != SQLITE_OK) return (jlong)0; return (jlong)pStmt; }
sqlite3_stmt * compile(JNIEnv* env, jobject object, sqlite3 * handle, jstring sqlString) { int err; jchar const * sql; jsize sqlLen; sqlite3_stmt * statement = GET_STATEMENT(env, object); // Make sure not to leak the statement if it already exists if (statement != NULL) { sqlite3_finalize(statement); env->SetIntField(object, gStatementField, 0); } // Compile the SQL sql = env->GetStringChars(sqlString, NULL); sqlLen = env->GetStringLength(sqlString); err = sqlite3_prepare16_v2(handle, sql, sqlLen * 2, &statement, NULL); env->ReleaseStringChars(sqlString, sql); if (err == SQLITE_OK) { // Store the statement in the Java object for future calls LOGV("Prepared statement %p on %p", statement, handle); env->SetIntField(object, gStatementField, (int)statement); return statement; } else { // Error messages like 'near ")": syntax error' are not // always helpful enough, so construct an error string that // includes the query itself. const char *query = env->GetStringUTFChars(sqlString, NULL); char *message = (char*) malloc(strlen(query) + 50); if (message) { strcpy(message, ", while compiling: "); // less than 50 chars strcat(message, query); } env->ReleaseStringUTFChars(sqlString, query); throw_sqlite3_exception(env, handle, message); free(message); return NULL; } }