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;
}
