static void native_clear_bindings(JNIEnv* env, jobject object) { int err; sqlite3_stmt * statement = GET_STATEMENT(env, object); err = sqlite3_clear_bindings(statement); if (err != SQLITE_OK) { throw_sqlite3_exception(env, GET_HANDLE(env, object)); return; } }
bool Object::findObjects(int frameID) { sqlite3_reset(m_findObjectsByFrameID); sqlite3_clear_bindings(m_findObjectsByFrameID); sqlite3_bind_int(m_findObjectsByFrameID, 1, frameID); m_currentSelect = m_findObjectsByFrameID; return true; }
void statement_imp::do_uses() { Error error = detail::sqliteError(__FILE__, __LINE__, sqlite3_clear_bindings (m_stmt)); if (error) Throw (error); for (uses_t::iterator iter = m_uses.begin (); iter != m_uses.end (); ++iter) (*iter)->do_use(); }
bool Object::findObjectsByVideoID(int videoID) { sqlite3_reset(m_findObjectsByVideoID); sqlite3_clear_bindings(m_findObjectsByVideoID); sqlite3_bind_int(m_findObjectsByVideoID, 1, videoID); m_currentSelect = m_findObjectsByVideoID; return true; }
/* Looks in the db for the tag ID (given) Returns 1 if it finds the tag UID in the db Returns 0 if it doesn't find the tag in the db Returns -1 if there is an error */ int touchatag_taglist_sqlite3_search_from_uid (char *tag_uid) { sqlite3_stmt *pStmt; sqlite3 *database; int rc, i = 0, b; if ((rc = sqlite3_open (dbname, &database)) != SQLITE_OK){ printf ("Error sqlite3_open ()\n"); return -1; } if ((rc = sqlite3_prepare_v2 (database, "SELECT * FROM tag WHERE UID=?", -1, &pStmt, NULL)) != SQLITE_OK){ printf("Error prepare_v2 #1 search\n"); return -1; } if ((rc = sqlite3_bind_text (pStmt, 1, tag_uid, -1, NULL)) != SQLITE_OK){ printf ("Error sqlite3_bind_text () in touchatag_taglist_sqlite3_search\n"); return -1; } if ((rc = sqlite3_step (pStmt)) != SQLITE_ROW){ i = sqlite3_clear_bindings (pStmt); if ((rc = sqlite3_reset (pStmt)) != SQLITE_OK){ printf ("Error sqlite3_reset () in touchatag_taglist_sqlite3_search\n"); return -1; } return 0; } i=sqlite3_clear_bindings (pStmt); if ((rc = sqlite3_reset (pStmt))!= SQLITE_OK){ printf ("Error sqlite3_reset () in touchatag_taglist_sqlite3_search\n"); return -1; } return 1; }
bool DB::Bindings::clear() { if (!isValid()) { DB::logError("Bindings::clear: statement is not valid"); return false; } if (sqlite3_clear_bindings(_handle->_stmt) != SQLITE_OK) { reportError(_handle->_stmt); return false; } return true; }
bool Object::findByLabel(string label) { sqlite3_reset(m_findObjectsByLabel); sqlite3_clear_bindings(m_findObjectsByLabel); sqlite3_bind_text(m_findObjectsByLabel, 1, label.c_str(), -1, SQLITE_STATIC); m_currentSelect = m_findObjectsByLabel; return true; }
/** * Convenience function to step a prepared statement with no * value once. * * @param context The current krb5_context * @param statement A prepared sqlite3 statement * * @return 0 if everything worked, an error code if not */ static krb5_error_code hdb_sqlite_step_once(krb5_context context, HDB *db, sqlite3_stmt *statement) { int ret; hdb_sqlite_db *hsdb = (hdb_sqlite_db *) db->hdb_db; ret = hdb_sqlite_step(context, hsdb->db, statement); sqlite3_clear_bindings(statement); sqlite3_reset(statement); return ret; }
SWIGEXPORT jint JNICALL Java_com_almworks_sqlite4java__1SQLiteSwiggedJNI_sqlite3_1clear_1bindings(JNIEnv *jenv, jclass jcls, jlong jarg1) { jint jresult = 0 ; sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; int result; (void)jenv; (void)jcls; arg1 = *(sqlite3_stmt **)&jarg1; result = (int)sqlite3_clear_bindings(arg1); jresult = (jint)result; return jresult; }
static int sec_sqlite3_reset(sqlite3_stmt *stmt, int s3e) { int s3e2; if (s3e == SQLITE_ROW || s3e == SQLITE_DONE) s3e = SQLITE_OK; s3e2 = sqlite3_reset(stmt); if (s3e2 && !s3e) s3e = s3e2; s3e2 = sqlite3_clear_bindings(stmt); if (s3e2 && !s3e) s3e = s3e2; return s3e; }
void QgsOSMDatabase::exportSpatiaLiteNodes( const QString& tableName, const QStringList& tagKeys ) { QString sqlInsertPoint = QString( "INSERT INTO %1 VALUES (?" ).arg( quotedIdentifier( tableName ) ); for ( int i = 0; i < tagKeys.count(); ++i ) sqlInsertPoint += QString( ",?" ); sqlInsertPoint += ", GeomFromWKB(?, 4326))"; sqlite3_stmt* stmtInsert; if ( sqlite3_prepare_v2( mDatabase, sqlInsertPoint.toUtf8().constData(), -1, &stmtInsert, 0 ) != SQLITE_OK ) { mError = "Prepare SELECT FROM nodes failed."; return; } QgsOSMNodeIterator nodes = listNodes(); QgsOSMNode n; while (( n = nodes.next() ).isValid() ) { QgsOSMTags t = tags( false, n.id() ); // skip untagged nodes: probably they form a part of ways if ( t.count() == 0 ) continue; QgsGeometry* geom = QgsGeometry::fromPoint( n.point() ); int col = 0; sqlite3_bind_int64( stmtInsert, ++col, n.id() ); // tags for ( int i = 0; i < tagKeys.count(); ++i ) { if ( t.contains( tagKeys[i] ) ) sqlite3_bind_text( stmtInsert, ++col, t.value( tagKeys[i] ).toUtf8().constData(), -1, SQLITE_TRANSIENT ); else sqlite3_bind_null( stmtInsert, ++col ); } sqlite3_bind_blob( stmtInsert, ++col, geom->asWkb(), geom->wkbSize(), SQLITE_STATIC ); int insertRes = sqlite3_step( stmtInsert ); if ( insertRes != SQLITE_DONE ) { mError = QString( "Error inserting node %1 [%2]" ).arg( n.id() ).arg( insertRes ); break; } sqlite3_reset( stmtInsert ); sqlite3_clear_bindings( stmtInsert ); delete geom; } sqlite3_finalize( stmtInsert ); }
static sqlite3_int64 append_log(char *line, struct pattern_rule *rule, regmatch_t *parens, time_t tstamp) { int err; size_t length; sqlite3_int64 last_log; if (2 < debug) { (void) fprintf( stdout, "match \"%.*s\"\n\tthread %ld \"%.*s\"\n", (int) (parens[0].rm_eo - parens[0].rm_so), line + parens[0].rm_so, rule->thread, (int) (parens[rule->thread].rm_eo - parens[rule->thread].rm_so), line + parens[rule->thread].rm_so ); } if (sqlite3_bind_int(ctx.insert_log, 1, rule->id_pattern) != SQLITE_OK) { sql_error(__FILE__, __LINE__, ctx.insert_log); goto error1; } if (sqlite3_bind_int(ctx.insert_log, 2, tstamp) != SQLITE_OK) { sql_error(__FILE__, __LINE__, ctx.insert_log); goto error1; } err = sqlite3_bind_text( ctx.insert_log, 3, line + parens[rule->thread].rm_so, parens[rule->thread].rm_eo - parens[rule->thread].rm_so, SQLITE_STATIC ); if (err != SQLITE_OK) { sql_error(__FILE__, __LINE__, ctx.insert_log); goto error1; } length = strlen(line); length = strlrspn(line, length, "\r\n"); if (sqlite3_bind_text(ctx.insert_log, 4, line, length, SQLITE_STATIC) != SQLITE_OK) { sql_error(__FILE__, __LINE__, ctx.insert_log); goto error1; } if (sql_step(ctx.db, ctx.insert_log) != SQLITE_DONE) { sql_error(__FILE__, __LINE__, ctx.insert_log); goto error1; } last_log = sqlite3_last_insert_rowid(ctx.db); (void) sqlite3_clear_bindings(ctx.insert_log); error1: return last_log; }
static void nativeResetStatementAndClearBindings(JNIEnv* env, jclass clazz, jlong connectionPtr, jlong statementPtr) { SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); int err = sqlite3_reset(statement); if (err == SQLITE_OK) { err = sqlite3_clear_bindings(statement); } if (err != SQLITE_OK) { throw_sqlite3_exception(env, connection->db, NULL); } }
static int gst_sqlite3_clear_bindings (OOP self) { sqlite3_stmt *stmt; SQLite3StmtHandle h; h = (SQLite3StmtHandle) OOP_TO_OBJ (self); if (h->stmt == vmProxy->nilOOP) return SQLITE_MISUSE; stmt = (sqlite3_stmt *) vmProxy->OOPToCObject (h->stmt); return sqlite3_clear_bindings (stmt); }
/* call-seq: stmt.clear_bindings! * * Resets the statement. This is typically done internally, though it might * occassionally be necessary to manually reset the statement. */ static VALUE clear_bindings(VALUE self) { sqlite3StmtRubyPtr ctx; Data_Get_Struct(self, sqlite3StmtRuby, ctx); REQUIRE_OPEN_STMT(ctx); sqlite3_clear_bindings(ctx->st); ctx->done_p = 0; return self; }
/** * Decrements the positions of contiguous services by one. * * @param [in] sl the service list to be modified. * @param [in] from the first position in the range. * @param [in] to the last position in the range. * * @return 0 if there is no error or non-zero if there is an error. */ static int dec_positions (service_list *sl, int from, int to) { int i; int rc; if ((rc = ensure_inc_dec_pos (sl))) { l->APP_ERR (rc, "inc_dec_pos is unavailable"); return ERR_DEC_POS; } if (sqlite3_reset (sl->inc_dec_pos)) { SQLITE3_ERR (sl->db, "Cannot reset inc_dec_pos"); return ERR_DEC_POS; } if (sqlite3_clear_bindings (sl->inc_dec_pos)) { SQLITE3_ERR (sl->db, "Cannot clear inc_dec_pos bindings"); return ERR_DEC_POS; } if (sqlite3_bind_int (sl->inc_dec_pos, 1, -1)) { SQLITE3_ERR (sl->db, "Cannot bind -1 to inc_dec_pos"); return ERR_DEC_POS; } for (i = from; i <= to; i++) { if (sqlite3_bind_int (sl->inc_dec_pos, 2, i)) { SQLITE3_ERR (sl->db, "Cannot bind pos #%d to inc_dec_pos", i); return ERR_DEC_POS; } if (sqlite3_step (sl->inc_dec_pos) != SQLITE_DONE) { SQLITE3_ERR (sl->db, "Cannot execute inc_dec_pos #%d", i); return ERR_DEC_POS; } if (sqlite3_reset (sl->inc_dec_pos)) { SQLITE3_ERR (sl->db, "Cannot reset inc_dec_pos #%d", i); return ERR_DEC_POS; } } return ERR_SUCCESS; }
static int32_t md_sqlite_execute_insert(struct md_writer_sqlite *mws, struct md_conn_event *mce) { int32_t retval; sqlite3_stmt *stmt = mws->insert_event; sqlite3_clear_bindings(stmt); sqlite3_reset(stmt); if (sqlite3_bind_int(stmt, 1, mws->node_id) || sqlite3_bind_int64(stmt, 2, mws->session_id) || sqlite3_bind_int64(stmt, 3, mws->session_id_multip) || sqlite3_bind_int64(stmt, 4, mce->tstamp) || sqlite3_bind_int(stmt, 5, mce->sequence) || sqlite3_bind_int(stmt, 6, mce->l3_session_id) || sqlite3_bind_int(stmt, 7, mce->l4_session_id) || sqlite3_bind_int(stmt, 8, mce->event_type) || sqlite3_bind_int(stmt, 9, mce->event_param) || sqlite3_bind_int(stmt, 12, mce->interface_type) || sqlite3_bind_int(stmt, 13, mce->interface_id_type) || sqlite3_bind_text(stmt, 14, mce->interface_id, strlen(mce->interface_id), SQLITE_STATIC) || sqlite3_bind_int(stmt, 16, mce->network_address_family) || sqlite3_bind_text(stmt, 17, mce->network_address, strlen(mce->network_address), SQLITE_STATIC)) { META_PRINT_SYSLOG(mws->parent, LOG_ERR, "Failed to bind values to INSERT query\n"); return SQLITE_ERROR; } if (mce->event_value != UINT8_MAX && sqlite3_bind_int(stmt, 10, mce->event_value)) { META_PRINT_SYSLOG(mws->parent, LOG_ERR, "Failed bind event value (int)\n"); return SQLITE_ERROR; } if (mce->event_value_str != NULL && sqlite3_bind_text(stmt, 11, mce->event_value_str, strlen(mce->event_value_str), SQLITE_STATIC)) { META_PRINT_SYSLOG(mws->parent, LOG_ERR, "Failed to bind event value (string)\n"); return SQLITE_ERROR; } if (mce->network_provider) { retval = sqlite3_bind_int(stmt, 15, mce->network_provider); if (retval) { META_PRINT_SYSLOG(mws->parent, LOG_ERR, "Failed to bind provider to INSERT query\n"); return SQLITE_ERROR; } } return sqlite3_step(stmt); }
int gbDB_ExecSQL_Scalar_ReusingStmt(sqlite3_stmt* scalar_stmt) { int rowCount = 0; while(sqlite3_step(scalar_stmt) == SQLITE_ROW) { rowCount = sqlite3_column_int(scalar_stmt, 0); }//while sqlite3_clear_bindings(scalar_stmt); sqlite3_reset(scalar_stmt); return rowCount; }//gbDB_ExecSQL_Scalar_ReusingStmt
bool SqQuery::Execute() { int rc; /* If we don't have a result set and we have a column count, * create a result set pre-emptively. This is in case there * are no rows in the upcoming result set. */ if (!m_pResults && m_ColCount) { m_pResults = new SqResults(this); } /* If we've got results, throw them away */ if (m_pResults) { m_pResults->ResetResultCount(); } /* Fetch each row, if any */ while ((rc = sqlite3_step(m_pStmt)) == SQLITE_ROW) { /* This should NEVER happen but we're being safe. */ if (!m_pResults) { m_pResults = new SqResults(this); } m_pResults->PushResult(); } sqlite3 *db = m_pParent->GetDb(); if (rc != SQLITE_OK && rc != SQLITE_DONE && rc == sqlite3_errcode(db)) { /* Something happened... */ m_LastErrorCode = rc; m_LastError.assign(sqlite3_errmsg(db)); m_AffectedRows = 0; m_InsertID = 0; } else { m_LastErrorCode = SQLITE_OK; m_AffectedRows = (unsigned int)sqlite3_changes(db); m_InsertID = (unsigned int)sqlite3_last_insert_rowid(db); } /* Reset everything for the next execute */ sqlite3_reset(m_pStmt); sqlite3_clear_bindings(m_pStmt); return (m_LastErrorCode == SQLITE_OK); }
void he_item_db_insert(struct lt_db_t * db, he_item_t * item) { int status = 0; sqlite3_clear_bindings(db->he_item_insert); sqlite3_bind_int(db->he_item_insert, 1, item->id); sqlite3_bind_text(db->he_item_insert, 2, item->aegis, strlen(item->aegis), SQLITE_STATIC); sqlite3_bind_text(db->he_item_insert, 3, item->name, strlen(item->name), SQLITE_STATIC); sqlite3_bind_int(db->he_item_insert, 4, item->type); sqlite3_bind_int(db->he_item_insert, 5, item->buy); sqlite3_bind_int(db->he_item_insert, 6, item->sell); sqlite3_bind_int(db->he_item_insert, 7, item->weight); sqlite3_bind_int(db->he_item_insert, 8, item->atk); sqlite3_bind_int(db->he_item_insert, 9, item->matk); sqlite3_bind_int(db->he_item_insert, 10, item->def); sqlite3_bind_int(db->he_item_insert, 11, item->range); sqlite3_bind_int(db->he_item_insert, 12, item->slots); sqlite3_bind_int(db->he_item_insert, 13, item->job); sqlite3_bind_int(db->he_item_insert, 14, item->upper); sqlite3_bind_int(db->he_item_insert, 15, item->gender); sqlite3_bind_int(db->he_item_insert, 16, item->loc); sqlite3_bind_int(db->he_item_insert, 17, item->weaponlv); sqlite3_bind_int(db->he_item_insert, 18, item->equiplv[EQUIP_MIN]); sqlite3_bind_int(db->he_item_insert, 19, item->equiplv[EQUIP_MAX]); sqlite3_bind_int(db->he_item_insert, 20, item->refine); sqlite3_bind_int(db->he_item_insert, 21, item->view); sqlite3_bind_int(db->he_item_insert, 22, item->bindonequip); sqlite3_bind_int(db->he_item_insert, 23, item->buyingstore); sqlite3_bind_int(db->he_item_insert, 24, item->delay); sqlite3_bind_int(db->he_item_insert, 25, item->trade[TRADE_OVERRIDE]); sqlite3_bind_int(db->he_item_insert, 26, item->trade[TRADE_NODROP]); sqlite3_bind_int(db->he_item_insert, 27, item->trade[TRADE_NOTRADE]); sqlite3_bind_int(db->he_item_insert, 28, item->trade[TRADE_PARTNEROVERRIDE]); sqlite3_bind_int(db->he_item_insert, 29, item->trade[TRADE_NOSELLTONPC]); sqlite3_bind_int(db->he_item_insert, 30, item->trade[TRADE_NOCART]); sqlite3_bind_int(db->he_item_insert, 31, item->trade[TRADE_NOSTORAGE]); sqlite3_bind_int(db->he_item_insert, 32, item->trade[TRADE_NOGSTORAGE]); sqlite3_bind_int(db->he_item_insert, 33, item->trade[TRADE_NOMAIL]); sqlite3_bind_int(db->he_item_insert, 34, item->trade[TRADE_NOAUCTION]); sqlite3_bind_int(db->he_item_insert, 35, item->nouse[NOUSE_OVERRIDE]); sqlite3_bind_int(db->he_item_insert, 36, item->nouse[NOUSE_SITTING]); sqlite3_bind_int(db->he_item_insert, 37, item->stack[STACK_AMOUNT]); sqlite3_bind_int(db->he_item_insert, 38, item->stack[STACK_TYPE]); sqlite3_bind_int(db->he_item_insert, 39, item->sprite); sqlite3_bind_text(db->he_item_insert, 40, item->script, strlen(item->script), SQLITE_STATIC); sqlite3_bind_text(db->he_item_insert, 41, item->onequipscript, strlen(item->onequipscript), SQLITE_STATIC); sqlite3_bind_text(db->he_item_insert, 42, item->onunequipscript, strlen(item->onunequipscript), SQLITE_STATIC); status = sqlite3_step(db->he_item_insert); /*if(status != SQLITE_DONE) exit_abt("fatal error inserting item.");*/ sqlite3_reset(db->he_item_insert); }
static GError * _record_meta1ref(sqlite3 *db, const GPtrArray *new_assign_meta1ref) { GError *err = NULL; gint rc; guint idx; sqlite3_stmt *stmt = NULL; sqlite3_prepare_debug(rc, db, "REPLACE INTO meta1_ref" " (addr,state,prefixes) VALUES (?,?,?)", -1, &stmt, NULL); if (rc != SQLITE_OK && rc != SQLITE_DONE) { if ( rc == SQLITE_ERROR ) { GRID_DEBUG("Missing table meta1ref in DB"); return NULL; } return SQLITE_GERROR(db, rc); } for (idx=0; idx < new_assign_meta1ref->len; idx++) { gchar *m1ref = new_assign_meta1ref->pdata[idx]; gchar *addr, *ref, *nb; if ( ! meta0_utils_unpack_meta1ref(m1ref,&addr,&ref,&nb) ) continue; sqlite3_reset(stmt); sqlite3_clear_bindings(stmt); sqlite3_bind_text(stmt, 1, addr, -1, NULL); sqlite3_bind_text(stmt, 2, ref, -1, NULL); sqlite3_bind_text(stmt, 3, nb, -1, NULL); while (!err) { rc = sqlite3_step(stmt); if (rc == SQLITE_OK || rc == SQLITE_DONE) break; if (rc == SQLITE_BUSY) sleep(1); else err = SQLITE_GERROR(db, rc); } if (addr) g_free(addr); if (ref) g_free(ref); if (nb) g_free(nb); } sqlite3_finalize_debug(rc, stmt); return err; }
int kv_keyexists(void * obj, const char * k){ sqlite3 * db = (sqlite3 *)obj; static const char * query = "SELECT count(*) FROM keyvaluestore WHERE k = ?"; static sqlite3_stmt * stmt = 0; static sqlite3 * lastdb = 0; if(!stmt || db != lastdb){ if(stmt){ sqlite3_finalize(stmt); stmt = 0; } if(sqlite3_prepare_v2(db, query, -1, &stmt, 0) != SQLITE_OK){ fprintf(stderr, "\nerror: %s", sqlite3_errmsg(db)); sqlite3_finalize(stmt); stmt = 0; assert(0); return 0; } lastdb = db; } int retval = 0; sqlite3_bind_text(stmt, 1, k, -1, SQLITE_STATIC); int status = sqlite3_step(stmt); if(status == SQLITE_ROW){ int count = sqlite3_column_int(stmt, 0); assert(count == 0 || count == 1); retval = count; } else{ assert(0); } sqlite3_clear_bindings(stmt); sqlite3_reset(stmt); return retval; }
// reset statement void database_resetStatement ( sqlite3_stmt * pStatement ) { int status; status = sqlite3_reset ( pStatement ); if ( SQLITE_OK != status ) { fatalError ( "Error reseting SQL statement!", 1 ); } status = sqlite3_clear_bindings ( pStatement ); if ( SQLITE_OK != status ) { fatalError ( "Error clearing SQL statement bindings!", 1 ); } }
static int prv_exists(dmsettings *handle, const char *key, bool *exists) { DMC_ERR_MANAGE; DMC_FAIL(prv_bind_double_query(handle->stmt_exists, key, key)); *exists = sqlite3_column_int(handle->stmt_exists, 0) ? true : false; DMC_ON_ERR: sqlite3_reset(handle->stmt_exists); sqlite3_clear_bindings(handle->stmt_exists); return DMC_ERR; }
void RSSManager::markAllAsRead(int feedid) { if (feedid == 0) { sqlite3_step(markAllReadStmt); sqlite3_reset(markAllReadStmt); } else { sqlite3_clear_bindings(markAllFeedReadStmt); sqlite3_bind_int(markAllFeedReadStmt, 1, feedid); int rc = sqlite3_step(markAllFeedReadStmt); sqlite3_reset(markAllFeedReadStmt); } }
static void pk_backend_download_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data) { gchar *dir_path, *path, **pkg_ids, **pkg_tokens, *to_strv[] = {NULL, NULL}; guint i; GSList *repo; sqlite3_stmt *stmt; PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job); g_variant_get(params, "(^a&ss)", &pkg_ids, &dir_path); pk_backend_job_set_status (job, PK_STATUS_ENUM_DOWNLOAD); if ((sqlite3_prepare_v2(job_data->db, "SELECT summary, (full_name || '.' || ext) FROM pkglist NATURAL JOIN repos " "WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo", -1, &stmt, NULL) != SQLITE_OK)) { pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db)); goto out; } for (i = 0; pkg_ids[i]; i++) { pkg_tokens = pk_package_id_split(pkg_ids[i]); sqlite3_bind_text(stmt, 1, pkg_tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT); sqlite3_bind_text(stmt, 2, pkg_tokens[PK_PACKAGE_ID_VERSION], -1, SQLITE_TRANSIENT); sqlite3_bind_text(stmt, 3, pkg_tokens[PK_PACKAGE_ID_ARCH], -1, SQLITE_TRANSIENT); sqlite3_bind_text(stmt, 4, pkg_tokens[PK_PACKAGE_ID_DATA], -1, SQLITE_TRANSIENT); if (sqlite3_step(stmt) == SQLITE_ROW) { if ((repo = g_slist_find_custom(repos, pkg_tokens[PK_PACKAGE_ID_DATA], katja_cmp_repo))) { pk_backend_job_package(job, PK_INFO_ENUM_DOWNLOADING, pkg_ids[i], (gchar *) sqlite3_column_text(stmt, 0)); katja_pkgtools_download(KATJA_PKGTOOLS(repo->data), job, dir_path, pkg_tokens[PK_PACKAGE_ID_NAME]); path = g_build_filename(dir_path, (gchar *) sqlite3_column_text(stmt, 1), NULL); to_strv[0] = path; pk_backend_job_files(job, NULL, to_strv); g_free(path); } } sqlite3_clear_bindings(stmt); sqlite3_reset(stmt); g_strfreev(pkg_tokens); } out: sqlite3_finalize(stmt); pk_backend_job_finished (job); }
bool Statement::Reset() { int Err = sqlite3_reset(Inner); if (Err != SQLITE_OK) { LogError("Failed to reset statement."); return LogError(sqlite3_errstr(Err), false); } Err = sqlite3_clear_bindings(Inner); if (Err != SQLITE_OK) { LogError("Failed to clear bindings."); return LogError(sqlite3_errstr(Err), false); } return true; }
bool Object::nextObject(tObject &object) { int retval; if ((retval = sqlite3_step(m_currentSelect)) == SQLITE_DONE) { sqlite3_reset(m_currentSelect); sqlite3_clear_bindings(m_currentSelect); return false; } parseObject(object); return true; }
void Database::Query::reset() { sqlite3* db = getSqlite3(); if (db == NULL) return; int err; err = sqlite3_clear_bindings(_stmt); if (err) NIT_THROW_FMT(EX_DATABASE, "can't clear binding: %s", sqlite3_errmsg(db)); err = sqlite3_reset(_stmt); if (err) NIT_THROW_FMT(EX_DATABASE, "can't reset statement: %s", sqlite3_errmsg(db)); _stepResult = SQLITE_DONE; }
int lms_db_reset_stmt(sqlite3_stmt *stmt) { int r, ret; ret = r = sqlite3_reset(stmt); if (r != SQLITE_OK) fprintf(stderr, "ERROR: could not reset SQL statement: #%d\n", r); r = sqlite3_clear_bindings(stmt); ret += r; if (r != SQLITE_OK) fprintf(stderr, "ERROR: could not clear SQL: #%d\n", r); return ret; }