static mrb_value mrb_sqlite3_database_execute(mrb_state *mrb, mrb_value self) { int argc = 0; mrb_value* argv = NULL; mrb_value b = mrb_nil_value(); mrb_value value_context; mrb_sqlite3_database* db = NULL; mrb_value fields; int i, r, count; sqlite3_stmt* stmt = NULL; mrb_value args[2]; mrb_value query; mrb_get_args(mrb, "&S*", &b, &query, &argv, &argc); value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "context")); db = NULL; Data_Get_Struct(mrb, value_context, &mrb_sqlite3_database_type, db); if (!db) { mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument"); } r = sqlite3_prepare_v2(db->db, RSTRING_PTR(query), RSTRING_LEN(query), &stmt, NULL); if (r != SQLITE_OK) { if (stmt) { sqlite3_finalize(stmt); sqlite3_reset(stmt); } mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db)); } if (!stmt) { return mrb_nil_value(); } if (argc > 0) { const char* error = bind_values(mrb, db->db, stmt, argc, argv); if (error) { mrb_raise(mrb, E_ARGUMENT_ERROR, error); } } fields = mrb_ary_new(mrb); count = sqlite3_column_count(stmt); for (i = 0; i < count; i++) { const char* name = sqlite3_column_name(stmt, i); mrb_ary_push(mrb, fields, mrb_str_new_cstr(mrb, name)); } if (mrb_nil_p(b)) { struct RClass* _class_sqlite3; struct RClass* _class_sqlite3_resultset; mrb_value c; mrb_sqlite3_resultset* rs = (mrb_sqlite3_resultset*) malloc(sizeof(mrb_sqlite3_resultset)); if (!rs) { mrb_raise(mrb, E_RUNTIME_ERROR, "can't memory alloc"); } memset(rs, 0, sizeof(mrb_sqlite3_resultset)); rs->mrb = mrb; rs->stmt = stmt; _class_sqlite3 = mrb_class_get(mrb, "SQLite3"); _class_sqlite3_resultset = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_sqlite3), mrb_intern(mrb, "ResultSet"))); c = mrb_class_new_instance(mrb, 0, NULL, _class_sqlite3_resultset); mrb_iv_set(mrb, c, mrb_intern(mrb, "context"), mrb_obj_value( Data_Wrap_Struct(mrb, mrb->object_class, &mrb_sqlite3_resultset_type, (void*) rs))); mrb_iv_set(mrb, c, mrb_intern(mrb, "fields"), fields); mrb_iv_set(mrb, c, mrb_intern(mrb, "db"), self); mrb_iv_set(mrb, c, mrb_intern(mrb, "eof"), mrb_false_value()); return c; } while ((r = sqlite3_step(stmt)) == SQLITE_ROW) { int ai = mrb_gc_arena_save(mrb); args[0] = row_to_value(mrb, stmt); args[1] = fields; mrb_yield_argv(mrb, b, 2, args); mrb_gc_arena_restore(mrb, ai); } sqlite3_finalize(stmt); if (r != SQLITE_OK && r != SQLITE_DONE) { mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db)); } return mrb_nil_value(); }
/* Saves in ret the tag action if it exists Returns 0 if it doesn't exists Returns -1 if it there is an error */ int touchatag_taglist_sqlite3_copy_action (tag_t *tag, char *ret) { sqlite3_stmt *pStmt; sqlite3 *database; int rc, rf, i = 0; uid[14] = '\0'; data[96] = '\0'; if ((rc = sqlite3_open (dbname, &database)) != SQLITE_OK){ printf ("Error sqlite3_open ()\n"); return -1; } touchatag_sconvert (tag, uid, data); if ((rf = touchatag_taglist_sqlite3_search (tag)) == -1){ printf ("Error touchatag_taglist_sqlite3_search ()\n"); sqlite3_close (database); return -1; } if (rf == 0) { sqlite3_close (database); return 0; } if (rf == 1) { if ((rc = sqlite3_prepare_v2 (database,"SELECT * from tag WHERE UID=?", -1, &pStmt, NULL)) != SQLITE_OK){ printf ("Error sqlite3_prepare_v2 ()\n"); sqlite3_close (database); return -1; } if ((rc = sqlite3_bind_text (pStmt, 1, uid, -1, NULL)) != SQLITE_OK){ printf ("Error sqlite3_bind_text ()\n"); sqlite3_close (database); return -1; } if ((rc = sqlite3_step (pStmt)) != SQLITE_ROW){ printf ("Error sqlite3_step ()\n"); return -1; } res = sqlite3_column_text (pStmt, 2); sprintf (ret, "%s", res); i = sqlite3_clear_bindings (pStmt); if ((rc = sqlite3_reset (pStmt)) != SQLITE_OK){ printf ("Error sqlite3_reset ()\n"); sqlite3_close (database); return -1; } sqlite3_close (database); return 1; } }
/* Update (plus 1) the counter of the given tag (if it exists in the db) Returns 0 if it's not in the db Returns -1 if there is a problem */ int touchatag_taglist_sqlite3_update_counter_tag (tag_t *tag) { sqlite3_stmt *pStmt; sqlite3 *database; int rc, rf, i = 0; uid[14] = '\0'; data[96] = '\0'; if ((rc = sqlite3_open (dbname, &database)) != SQLITE_OK){ printf ("Error sqlite3_open ()\n"); return -1; } touchatag_sconvert (tag, uid, data); if ((rf = touchatag_taglist_sqlite3_counter_tag (tag)) == -1){ printf ("Error touchatag_taglist_sqlite3_counter_tag () in touchatag_taglist_sqlite3_update_counter_tag ()\n"); sqlite3_close (database); return -1; } if (rf == -2) { sqlite3_close (database); return 0; } rf++; if ((rc = sqlite3_prepare_v2 (database,"UPDATE tag SET CONT=? WHERE UID=?", -1, &pStmt, NULL)) != SQLITE_OK){ printf ("Error sqlite3_prepare_v2 () in touchatag_taglist_sqlite3_update_counter_tag ()\n"); sqlite3_close (database); return -1; } if ((rc = sqlite3_bind_int (pStmt, 1, rf)) != SQLITE_OK){ printf ("Error sqlite3_bind_int () in touchatag_taglist_sqlite3_update_counter_tag ()\n"); sqlite3_close (database); return -1; } if ((rc = sqlite3_bind_text (pStmt, 2, (const char*)uid, -1, NULL)) != SQLITE_OK){ printf ("Error sqlite3_bind_text () in touchatag_taglist_sqlite3_update_counter_tag ()\n"); sqlite3_close (database); return -1; } if ((rc = sqlite3_step (pStmt)) != SQLITE_DONE){ printf ("Error sqlite3_step () in touchatag_taglist_sqlite3_update_counter_tag ()\n"); sqlite3_close (database); return -1; } i = sqlite3_clear_bindings (pStmt); if ((rc = sqlite3_reset (pStmt))!= SQLITE_OK){ printf ("Error sqlite3_reset () in touchatag_taglist_sqlite3_update_counter_tag ()\n"); sqlite3_close (database); return -1; } sqlite3_close (database); return 1; }
void Statement::reset() { assert(stmt); sqlite3_reset(stmt); }
static void print_by_size(void) { int ret; int header_printed = 0; unsigned char *digest; uint64_t count, files_count; if (print_all_hashes) printf("Print all hashes "); else printf("Print top %d hashes ", num_to_print); printf("(this may take some time)\n"); while ((ret = sqlite3_step(top_hashes_stmt)) == SQLITE_ROW) { digest = (unsigned char *)sqlite3_column_blob(top_hashes_stmt, 0); count = sqlite3_column_int64(top_hashes_stmt, 1); ret = sqlite3_bind_blob(files_count_stmt, 1, digest, digest_len, SQLITE_STATIC); if (ret) { fprintf(stderr, "Error %d binding digest: %s\n", ret, sqlite3_errstr(ret)); return; } ret = sqlite3_step(files_count_stmt); if (ret != SQLITE_ROW && ret != SQLITE_DONE) { fprintf(stderr, "error %d, file count search: %s\n", ret, sqlite3_errstr(ret)); return; } files_count = sqlite3_column_int64(files_count_stmt, 0); if (!header_printed) { printf("Hash, # Blocks, # Files\n"); header_printed = 1; } debug_print_digest(stdout, digest); printf(", %"PRIu64", %"PRIu64"\n", count, files_count); sqlite3_reset(files_count_stmt); if (print_blocks) { ret = print_all_blocks(digest); if (ret) return; } if (!print_all_hashes && --num_to_print == 0) { ret = SQLITE_DONE; break; } } if (ret != SQLITE_DONE) { fprintf(stderr, "error %d retrieving hashes from table: %s\n", ret, sqlite3_errstr(ret)); } }
/* insert a measurement report into the database */ int meas_db_insert(struct meas_db_state *st, const char *imsi, const char *name, unsigned long timestamp, const char *scenario, const struct gsm_meas_rep *mr) { int rc; sqlite3_int64 rowid, ul_rowid, dl_rowid; SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 1, timestamp)); if (imsi) SCK_OK(st->db, sqlite3_bind_text(st->stmt_ins_mr, 2, imsi, -1, SQLITE_STATIC)); else SCK_OK(st->db, sqlite3_bind_null(st->stmt_ins_mr, 2)); if (name) SCK_OK(st->db, sqlite3_bind_text(st->stmt_ins_mr, 3, name, -1, SQLITE_STATIC)); else SCK_OK(st->db, sqlite3_bind_null(st->stmt_ins_mr, 3)); if (scenario) SCK_OK(st->db, sqlite3_bind_text(st->stmt_ins_mr, 4, scenario, -1, SQLITE_STATIC)); else SCK_OK(st->db, sqlite3_bind_null(st->stmt_ins_mr, 4)); SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 5, mr->nr)); SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 6, mr->bs_power)); if (mr->flags & MEAS_REP_F_MS_TO) SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 7, mr->ms_timing_offset)); else SCK_OK(st->db, sqlite3_bind_null(st->stmt_ins_mr, 7)); if (mr->flags & MEAS_REP_F_FPC) SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 8, 1)); else SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 8, 0)); if (mr->flags & MEAS_REP_F_MS_L1) { SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 9, mr->ms_l1.pwr)); SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_mr, 10, mr->ms_l1.ta)); } SCK_DONE(st->db, sqlite3_step(st->stmt_ins_mr)); SCK_OK(st->db, sqlite3_reset(st->stmt_ins_mr)); rowid = sqlite3_last_insert_rowid(st->db); /* insert uplink measurement */ ul_rowid = _insert_ud(st, rowid, mr->flags & MEAS_REP_F_UL_DTX, 1, &mr->ul); SCK_OK(st->db, sqlite3_bind_int(st->stmt_upd_mr, 1, ul_rowid)); /* insert downlink measurement, if present */ if (mr->flags & MEAS_REP_F_DL_VALID) { dl_rowid = _insert_ud(st, rowid, mr->flags & MEAS_REP_F_DL_DTX, 0, &mr->dl); SCK_OK(st->db, sqlite3_bind_int(st->stmt_upd_mr, 2, dl_rowid)); } else SCK_OK(st->db, sqlite3_bind_null(st->stmt_upd_mr, 2)); /* update meas_rep with the id's of the unidirectional * measurements */ SCK_OK(st->db, sqlite3_bind_int(st->stmt_upd_mr, 3, rowid)); SCK_DONE(st->db, sqlite3_step(st->stmt_upd_mr)); SCK_OK(st->db, sqlite3_reset(st->stmt_upd_mr)); return 0; err_io: return -EIO; }
bool QSQLiteResult::exec() { const QVector<QVariant> values = boundValues(); d->skippedStatus = false; d->skipRow = false; d->rInf.clear(); clearValues(); setLastError(QSqlError()); int res = sqlite3_reset(d->stmt); if (res != SQLITE_OK) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult", "Unable to reset statement"), QSqlError::StatementError, res)); d->finalize(); return false; } int paramCount = sqlite3_bind_parameter_count(d->stmt); if (paramCount == values.count()) { for (int i = 0; i < paramCount; ++i) { res = SQLITE_OK; const QVariant value = values.at(i); if (value.isNull()) { res = sqlite3_bind_null(d->stmt, i + 1); } else { switch (value.type()) { case QVariant::ByteArray: { const QByteArray *ba = static_cast<const QByteArray*>(value.constData()); res = sqlite3_bind_blob(d->stmt, i + 1, ba->constData(), ba->size(), SQLITE_STATIC); break; } case QVariant::Int: res = sqlite3_bind_int(d->stmt, i + 1, value.toInt()); break; case QVariant::Double: res = sqlite3_bind_double(d->stmt, i + 1, value.toDouble()); break; case QVariant::UInt: case QVariant::LongLong: res = sqlite3_bind_int64(d->stmt, i + 1, value.toLongLong()); break; case QVariant::String: { // lifetime of string == lifetime of its qvariant const QString *str = static_cast<const QString*>(value.constData()); res = sqlite3_bind_text16(d->stmt, i + 1, str->utf16(), (str->size()) * sizeof(QChar), SQLITE_STATIC); break; } default: { QString str = value.toString(); // SQLITE_TRANSIENT makes sure that sqlite buffers the data res = sqlite3_bind_text16(d->stmt, i + 1, str.utf16(), (str.size()) * sizeof(QChar), SQLITE_TRANSIENT); break; } } } if (res != SQLITE_OK) { setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult", "Unable to bind parameters"), QSqlError::StatementError, res)); d->finalize(); return false; } } } else { setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult", "Parameter count mismatch"), QString(), QSqlError::StatementError)); return false; } d->skippedStatus = d->fetchNext(d->firstRow, 0, true); if (lastError().isValid()) { setSelect(false); setActive(false); return false; } setSelect(!d->rInf.isEmpty()); setActive(true); return true; }
static int unbump_revs(struct revunbump_data_t *unb) { int64_t revs[MAX_UNBUMPS]; sqlite3_stmt *q; char *qry = NULL; const void *tgt; unsigned int i, qlen = 0, qat = 0; int64_t unbid; const sx_node_t *target, *me; int r, err = 0, remote; q = unb->quget_hi; sqlite3_reset(q); if(qbind_blob(q, ":oldtarget", (const void *)&unb->last_target, sizeof(unb->last_target))) return -1; /* Error */ r = qstep(q); if(r == SQLITE_DONE) { q = unb->quget_lo; sqlite3_reset(q); if(qbind_blob(q, ":oldtarget", (const void *)&unb->last_target, sizeof(unb->last_target))) return -1; /* Error */ r = qstep(q); if(r == SQLITE_DONE) return 0; /* Work complete */ } if(r != SQLITE_ROW) return -1; /* Error */ unbid = sqlite3_column_int64(q, 0); tgt = sqlite3_column_blob(q, 3); if(!tgt || sqlite3_column_bytes(q, 3) != sizeof(unb->last_target.binary)) { WARN("Removing unbid %lld with bogus target", (long long)unbid); sqlite3_reset(q); return unbump_unq(unb, unbid); } uuid_from_binary(&unb->last_target, tgt); target = sx_nodelist_lookup(sx_hashfs_all_nodes(unb->hashfs, NL_NEXTPREV), &unb->last_target); if(!target) { DEBUG("Removing unbid %lld for target node %s which is no longer a member", (long long)unbid, unb->last_target.string); sqlite3_reset(q); return unbump_unq(unb, unbid); } if(sx_hashfs_is_node_ignored(unb->hashfs, &unb->last_target)) { /* These will be sent once there is a replacement */ DEBUG("Skipping requests for unbid %lld for target node %s which is no longer a member", (long long)unbid, unb->last_target.string); sqlite3_reset(q); return 0; /* Work complete */ } me = sx_hashfs_self(unb->hashfs); remote = sx_node_cmp(me, target); if(!remote && sx_hashfs_revision_op_begin(unb->hashfs)) { WARN("Failed to start revision operation: %s", msg_get_reason()); sqlite3_reset(q); return -1; /* Error */ } for(i=0; i<MAX_UNBUMPS;) { const sx_hash_t *revid; unsigned int bs = sqlite3_column_int(q, 2); if(sx_hashfs_check_blocksize(bs)) WARN("Removing unbid %lld with invalid block size %u", (long long)unbid, bs); else if(!(revid = sqlite3_column_blob(q, 1)) || sqlite3_column_bytes(q, 1) != sizeof(*revid)) WARN("Removing unbid %lld with bogus revision ID", (long long)unbid); else if(!(tgt = sqlite3_column_blob(q, 3)) || sqlite3_column_bytes(q, 3) != sizeof(unb->last_target.binary)) WARN("Removing unbid %lld with bogus target", (long long)unbid); else if(memcmp(tgt, &unb->last_target.binary, sizeof(unb->last_target.binary))) break; else if(remote) { /* Remote target */ if(qlen - qat < sizeof(*revid) * 2 + sizeof(",\"\":") + 32) { /* Make room for hex encoded rev, size and json glue */ qlen += 1024; qry = wrap_realloc_or_free(qry, qlen); if(!qry) { WARN("Unable to allocate query"); err = 1; break; } } qry[qat] = qat ? ',' : '{'; qry[qat+1] = '"'; qat += 2; bin2hex(revid, sizeof(*revid), &qry[qat], qlen - qat); qat += sizeof(*revid)*2; qat += snprintf(&qry[qat], qlen - qat,"\":%u", bs); } else { /* Local target */ if(sx_hashfs_revision_op(unb->hashfs, bs, revid, -1) != OK) { WARN("Failed to unbump local revision"); err = 1; break; } } revs[i++] = sqlite3_column_int64(q, 0); r = qstep(q); if(r == SQLITE_ROW) continue; else if(r != SQLITE_DONE) { WARN("Failed to retrieve next revision"); err = 1; } break; } sqlite3_reset(q); if(!remote) { /* Commit local revision ops... */ if(!err && sx_hashfs_revision_op_commit(unb->hashfs)) { WARN("Failed to commit revision operation: %s", msg_get_reason()); err = 1; } /* ... or rollback on error */ if(err) sx_hashfs_revision_op_rollback(unb->hashfs); } if(err) { free(qry); return -1; /* Error */ } if(remote && qry) { sxi_conns_t *clust = sx_hashfs_conns(unb->hashfs); sxc_client_t *sx = sx_hashfs_client(unb->hashfs); sxi_hostlist_t hlist; int qret; sxi_hostlist_init(&hlist); if(qlen - qat < 2) { qry = wrap_realloc_or_free(qry, qlen + 2); if(!qry) { WARN("Unable to allocate query"); return -1; /* Error */ } } qry[qat] = '}'; qry[qat+1] = '\0'; if(sxi_hostlist_add_host(sx, &hlist, sx_node_internal_addr(target))) { WARN("Unable to allocate hostlist"); free(qry); return -1; /* Error */ } qret = sxi_cluster_query(clust, &hlist, REQ_PUT, ".blockrevs/remove", qry, strlen(qry), NULL, NULL, NULL); free(qry); qry = NULL; sxi_hostlist_empty(&hlist); if(qret != 200) { WARN("Unbump request failed for %s (%s): HTTP status %d", unb->last_target.string, sx_node_internal_addr(target), qret); return -1; } } free(qry); while(i--) unbump_unq(unb, revs[i]); return 1; /* Some work done */ }
void RepoStmt::reset() { sqlite3_reset(m_stmt); sqlite3_clear_bindings(m_stmt); }
DWORD SamDbDeleteObject( HANDLE hDirectory, PWSTR pwszObjectDN ) { DWORD dwError = 0; PSAM_DIRECTORY_CONTEXT pDirectoryContext = NULL; PSTR pszObjectDN = NULL; PSAM_DB_DN pDN = NULL; BOOLEAN bInLock = FALSE; DWORD dwNumDependents = 0; pDirectoryContext = (PSAM_DIRECTORY_CONTEXT)hDirectory; if (!hDirectory || !pwszObjectDN || !*pwszObjectDN) { dwError = LW_ERROR_INVALID_PARAMETER; BAIL_ON_SAMDB_ERROR(dwError); } dwError = SamDbParseDN( pwszObjectDN, &pDN); BAIL_ON_SAMDB_ERROR(dwError); dwError = LwWc16sToMbs( pwszObjectDN, &pszObjectDN); BAIL_ON_SAMDB_ERROR(dwError); SAMDB_LOCK_RWMUTEX_EXCLUSIVE(bInLock, &gSamGlobals.rwLock); dwError = SamDbGetNumberOfDependents_inlock( pDirectoryContext, pszObjectDN, &dwNumDependents); BAIL_ON_SAMDB_ERROR(dwError); if (dwNumDependents) { dwError = LW_ERROR_OBJECT_IN_USE; BAIL_ON_SAMDB_ERROR(dwError); } if (!pDirectoryContext->pDbContext->pDelObjectStmt) { PCSTR pszDelQueryTemplate = "DELETE FROM " SAM_DB_OBJECTS_TABLE \ " WHERE " SAM_DB_COL_DISTINGUISHED_NAME " = ?1;"; dwError = sqlite3_prepare_v2( pDirectoryContext->pDbContext->pDbHandle, pszDelQueryTemplate, -1, &pDirectoryContext->pDbContext->pDelObjectStmt, NULL); BAIL_ON_SAMDB_SQLITE_ERROR_DB( dwError, pDirectoryContext->pDbContext->pDbHandle); } dwError = sqlite3_bind_text( pDirectoryContext->pDbContext->pDelObjectStmt, 1, pszObjectDN, -1, SQLITE_TRANSIENT); BAIL_ON_SAMDB_SQLITE_ERROR_STMT( dwError, pDirectoryContext->pDbContext->pDelObjectStmt); dwError = sqlite3_step(pDirectoryContext->pDbContext->pDelObjectStmt); if (dwError == SQLITE_DONE) { dwError = LW_ERROR_SUCCESS; } BAIL_ON_SAMDB_SQLITE_ERROR_STMT( dwError, pDirectoryContext->pDbContext->pDelObjectStmt); dwError = SamDbIncrementSequenceNumber_inlock( pDirectoryContext); BAIL_ON_SAMDB_ERROR(dwError); cleanup: if (pDirectoryContext->pDbContext->pDelObjectStmt) { sqlite3_reset(pDirectoryContext->pDbContext->pDelObjectStmt); } SAMDB_UNLOCK_RWMUTEX(bInLock, &gSamGlobals.rwLock); DIRECTORY_FREE_STRING(pszObjectDN); if (pDN) { SamDbFreeDN(pDN); } return dwError; error: goto cleanup; }
static int schedule_blocks_sfq(struct blockmgr_data_t *q) { sx_uuid_t target_uuid; sqlite3_stmt *qget; int ret = 0, r; DEBUG("in %s", __func__); qget = q->qget_first_hi; if(qbind_int64(qget, ":flow", q->last_flowid)) { WARN("Error retrieving master block from queue"); return -1; } r = qstep(qget); if(r == SQLITE_DONE) { qget = q->qget_first_lo; if(qbind_int64(qget, ":flow", q->last_flowid)) { WARN("Error retrieving master block from queue"); return -1; } r = qstep(qget); } if(r == SQLITE_DONE) { DEBUG("No blocks in the queue"); return 0; } if(r != SQLITE_ROW) { WARN("Error retrieving master block from queue"); return -1; } do { int64_t push_id; const void *p; int i; /* SELECT id, flow, block[, size, node] */ push_id = sqlite3_column_int64(qget, 0); q->last_flowid = sqlite3_column_int64(qget, 1); if(!ret) { /* First block is the "master" and dictates blocksize and target node */ q->blocksize = sqlite3_column_int(qget, 3); if(sx_hashfs_check_blocksize(q->blocksize)) { WARN("Removing block with invalid blocksize %u", q->blocksize); sqlite3_reset(qget); blockmgr_del_xfer(q, push_id); return schedule_blocks_sfq(q); } p = sqlite3_column_blob(qget, 4); if(sqlite3_column_bytes(qget, 4) != sizeof(target_uuid.binary)) { WARN("Removing block with invalid target node UUID"); sqlite3_reset(qget); blockmgr_del_xfer(q, push_id); return schedule_blocks_sfq(q); } uuid_from_binary(&target_uuid, p); if(!(q->target = sx_nodelist_lookup(sx_hashfs_effective_nodes(q->hashfs, NL_NEXT), &target_uuid))) { DEBUG("Removing transfer to non existing (possibly ignored) node %s", target_uuid.string); sqlite3_reset(qget); blockmgr_del_xfer(q, push_id); return schedule_blocks_sfq(q); } if(!sx_node_cmp(q->target, sx_hashfs_self(q->hashfs))) { WARN("Removing transfer to self"); sqlite3_reset(qget); blockmgr_del_xfer(q, push_id); return schedule_blocks_sfq(q); } DEBUG("Selected master block for transfer bs: %u, node: %s", q->blocksize, target_uuid.string); } p = sqlite3_column_blob(qget, 2); if(sqlite3_column_bytes(qget, 2) != SXI_SHA1_BIN_LEN) { if(!ret) { /* Remove "master" block from queue */ WARN("Removing block with invalid hash"); sqlite3_reset(qget); blockmgr_del_xfer(q, push_id); return schedule_blocks_sfq(q); } else /* Or silently skip slaves (they'll be pruned in the subsequent loops) */ continue; } q->hashlist.ids[ret] = push_id; q->hashlist.havehs[ret] = 0; memcpy(&q->hashlist.binhs[ret], p, SXI_SHA1_BIN_LEN); sqlite3_reset(qget); if(!ret && qstep_noret(q->qwipesched)) { sqlite3_reset(qget); WARN("Failed to wipe schedule"); return -1; } if(qbind_int64(q->qaddsched, ":pushid", push_id) || qstep_noret(q->qaddsched)) { WARN("Failed to schedule block transfer"); return -1; } /* do { char hexh[SXI_SHA1_BIN_LEN * 2 + 1]; sxi_bin2hex(&q->hashlist.binhs[ret], SXI_SHA1_BIN_LEN, hexh); INFO("Block %s scheduled for transfer", hexh); } while(0); */ ret++; if(ret >= DOWNLOAD_MAX_BLOCKS) break; for(i = 0; i<2; i++) { /* Failure is not severe here: we just ship what we have scheduled so far and call it a day */ qget = (i == 0) ? q->qget_next_hi : q->qget_next_lo; if(qbind_int64(qget, ":flow", q->last_flowid) || qbind_int(qget, ":size", q->blocksize) || qbind_blob(qget, ":node", target_uuid.binary, sizeof(target_uuid.binary))) { WARN("Error retrieving next slave block from queue"); r = SQLITE_DONE; break; } r = qstep(qget); if(r == SQLITE_ROW) break; if(r != SQLITE_DONE) { WARN("Error retrieving next slave block from queue"); break; } } } while(r == SQLITE_ROW); q->hashlist.nblocks = ret; DEBUG("Successfully scheduled %d blocks for transfer", ret); return ret; }
int machine_reset(Pointer stmt) { reset_ready_event( EV_Done| EV_Data | EV_Error); return msg_id(sqlite3_reset((sqlite3_stmt*)stmt));}
static tb_bool_t tb_database_sqlite3_statement_done(tb_database_sql_impl_t* database, tb_database_sql_statement_ref_t statement) { // check tb_database_sqlite3_t* sqlite = tb_database_sqlite3_cast(database); tb_assert_and_check_return_val(sqlite && sqlite->database && statement, tb_false); // done tb_bool_t ok = tb_false; do { // exit result first if exists if (sqlite->result.result) sqlite3_free_table(sqlite->result.result); sqlite->result.result = tb_null; // clear the last statement first sqlite->result.statement = tb_null; // clear the result row count first sqlite->result.count = 0; // clear the result col count first sqlite->result.row.count = 0; // step statement tb_int_t result = sqlite3_step((sqlite3_stmt*)statement); tb_assert_and_check_break(result == SQLITE_DONE || result == SQLITE_ROW); // exists result? if (result == SQLITE_ROW) { // save the result iterator mode sqlite->result.itor.mode = TB_ITERATOR_MODE_FORWARD | TB_ITERATOR_MODE_READONLY; // save statement for iterating it sqlite->result.statement = (sqlite3_stmt*)statement; // save result row count sqlite->result.count = (tb_size_t)-1; // save result col count sqlite->result.row.count = sqlite3_column_count((sqlite3_stmt*)statement); } else { // reset it if (SQLITE_OK != sqlite3_reset((sqlite3_stmt*)statement)) { // save state sqlite->base.state = tb_database_sqlite3_state_from_errno(sqlite3_errcode(sqlite->database)); // trace tb_trace_e("statement: reset failed, error[%d]: %s", sqlite3_errcode(sqlite->database), sqlite3_errmsg(sqlite->database)); // failed break; } } // ok ok = tb_true; } while (0); // ok? return ok; }
static mrb_value mrb_sqlite3_database_execute_batch(mrb_state *mrb, mrb_value self) { int argc = 0; mrb_value *argv; mrb_value value_context; mrb_sqlite3_database* db = NULL; mrb_value query; int len; char* top; const char *tail, *sql; mrb_get_args(mrb, "*", &argv, &argc); if (argc == 0) { mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument"); } value_context = mrb_iv_get(mrb, self, mrb_intern(mrb, "context")); Data_Get_Struct(mrb, value_context, &mrb_sqlite3_database_type, db); if (!db) { mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument"); } query = argv[0]; len = RSTRING_LEN(query); top = malloc(len + 1); if (!top) { mrb_raise(mrb, E_RUNTIME_ERROR, "can't memory alloc"); } memcpy(top, RSTRING_PTR(query), len); top[len] = 0; tail = (const char*) top; while (*(sql = tail)) { sqlite3_stmt* stmt = NULL; int r = sqlite3_prepare_v2(db->db, sql, -1, &stmt, &tail); if (argc > 1) { const char* error = bind_values(mrb, db->db, stmt, argc-1, &argv[1]); argc = 0; if (error) { free(top); mrb_raise(mrb, E_ARGUMENT_ERROR, error); } } if (r != SQLITE_OK) { if (stmt) { sqlite3_finalize(stmt); sqlite3_reset(stmt); } free(top); mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db)); } if (stmt) { r = sqlite3_step(stmt); sqlite3_finalize(stmt); if (r != SQLITE_OK && r != SQLITE_DONE) { free(top); mrb_raise(mrb, E_RUNTIME_ERROR, sqlite3_errmsg(db->db)); } } } free(top); return mrb_fixnum_value(sqlite3_changes(db->db)); }
void Database_SQLite3::saveBlock(MapBlock *block) { DSTACK(__FUNCTION_NAME); /* Dummy blocks are not written */ if(block->isDummy()) { /*v3s16 p = block->getPos(); infostream<<"Database_SQLite3::saveBlock(): WARNING: Not writing dummy block " <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/ return; } // Format used for writing u8 version = SER_FMT_VER_HIGHEST; // Get destination v3s16 p3d = block->getPos(); #if 0 v2s16 p2d(p3d.X, p3d.Z); std::string sectordir = getSectorDir(p2d); createDirs(sectordir); std::string fullpath = sectordir+DIR_DELIM+getBlockFilename(p3d); std::ofstream o(fullpath.c_str(), std::ios_base::binary); if(o.good() == false) throw FileNotGoodException("Cannot open block data"); #endif /* [0] u8 serialization version [1] data */ verifyDatabase(); std::ostringstream o(std::ios_base::binary); o.write((char*)&version, 1); // Write basic data block->serialize(o, version, true); // Write block to database std::string tmp = o.str(); const char *bytes = tmp.c_str(); if(sqlite3_bind_int64(m_database_write, 1, getBlockAsInteger(p3d)) != SQLITE_OK) infostream<<"WARNING: Block position failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl; if(sqlite3_bind_blob(m_database_write, 2, (void *)bytes, o.tellp(), NULL) != SQLITE_OK) // TODO this mught not be the right length infostream<<"WARNING: Block data failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl; int written = sqlite3_step(m_database_write); if(written != SQLITE_DONE) infostream<<"WARNING: Block failed to save ("<<p3d.X<<", "<<p3d.Y<<", "<<p3d.Z<<") " <<sqlite3_errmsg(m_database)<<std::endl; // Make ready for later reuse sqlite3_reset(m_database_write); // We just wrote it to the disk so clear modified flag block->resetModified(); }
static char *handle_cli_database_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) { char prefix[MAX_DB_FIELD]; int counter = 0; sqlite3_stmt *stmt = gettree_stmt; switch (cmd) { case CLI_INIT: e->command = "database show"; e->usage = "Usage: database show [family [keytree]]\n" " OR: database show [family[/keytree]]\n" " Shows Asterisk database contents, optionally restricted\n" " to a given family, or family and keytree. The two arguments\n" " may be separated either by a space or by a slash.\n"; return NULL; case CLI_GENERATE: return NULL; } if (a->argc == 4) { /* Family and key tree */ snprintf(prefix, sizeof(prefix), "/%s/%s", a->argv[2], a->argv[3]); } else if (a->argc == 3) { /* Family only */ snprintf(prefix, sizeof(prefix), "/%s", a->argv[2]); } else if (a->argc == 2) { /* Neither */ prefix[0] = '\0'; stmt = gettree_all_stmt; } else { return CLI_SHOWUSAGE; } ast_mutex_lock(&dblock); if (!ast_strlen_zero(prefix) && (sqlite3_bind_text(stmt, 1, prefix, -1, SQLITE_STATIC) != SQLITE_OK)) { ast_log(LOG_WARNING, "Could bind %s to stmt: %s\n", prefix, sqlite3_errmsg(astdb)); sqlite3_reset(stmt); ast_mutex_unlock(&dblock); return NULL; } while (sqlite3_step(stmt) == SQLITE_ROW) { const char *key_s, *value_s; if (!(key_s = (const char *) sqlite3_column_text(stmt, 0))) { ast_log(LOG_WARNING, "Skipping invalid key!\n"); continue; } if (!(value_s = (const char *) sqlite3_column_text(stmt, 1))) { ast_log(LOG_WARNING, "Skipping invalid value!\n"); continue; } ++counter; ast_cli(a->fd, "%-50s: %-25s\n", key_s, value_s); } sqlite3_reset(stmt); ast_mutex_unlock(&dblock); ast_cli(a->fd, "%d results found.\n", counter); return CLI_SUCCESS; }
MapBlock* Database_SQLite3::loadBlock(v3s16 blockpos) { v2s16 p2d(blockpos.X, blockpos.Z); verifyDatabase(); if(sqlite3_bind_int64(m_database_read, 1, getBlockAsInteger(blockpos)) != SQLITE_OK) infostream<<"WARNING: Could not bind block position for load: " <<sqlite3_errmsg(m_database)<<std::endl; if(sqlite3_step(m_database_read) == SQLITE_ROW) { /* Make sure sector is loaded */ MapSector *sector = srvmap->createSector(p2d); /* Load block */ const char * data = (const char *)sqlite3_column_blob(m_database_read, 0); size_t len = sqlite3_column_bytes(m_database_read, 0); std::string datastr(data, len); // srvmap->loadBlock(&datastr, blockpos, sector, false); try { std::istringstream is(datastr, std::ios_base::binary); u8 version = SER_FMT_VER_INVALID; is.read((char*)&version, 1); if(is.fail()) throw SerializationError("ServerMap::loadBlock(): Failed" " to read MapBlock version"); MapBlock *block = NULL; bool created_new = false; block = sector->getBlockNoCreateNoEx(blockpos.Y); if(block == NULL) { block = sector->createBlankBlockNoInsert(blockpos.Y); created_new = true; } // Read basic data block->deSerialize(is, version, true); // If it's a new block, insert it to the map if(created_new) sector->insertBlock(block); /* Save blocks loaded in old format in new format */ //if(version < SER_FMT_VER_HIGHEST || save_after_load) // Only save if asked to; no need to update version //if(save_after_load) // saveBlock(block); // We just loaded it from, so it's up-to-date. block->resetModified(); } catch(SerializationError &e) { errorstream<<"Invalid block data in database" <<" ("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<")" <<" (SerializationError): "<<e.what()<<std::endl; // TODO: Block should be marked as invalid in memory so that it is // not touched but the game can run if(g_settings->getBool("ignore_world_load_errors")){ errorstream<<"Ignoring block load error. Duck and cover! " <<"(ignore_world_load_errors)"<<std::endl; } else { throw SerializationError("Invalid block data in database"); //assert(0); } } sqlite3_step(m_database_read); // We should never get more than 1 row, so ok to reset sqlite3_reset(m_database_read); return srvmap->getBlockNoCreateNoEx(blockpos); // should not be using this here } sqlite3_reset(m_database_read); return(NULL); }
bool Sqlite3Connection::Execute() { Cancel(); if(statement.GetLength() == 0) { session.SetError("Empty statement", String("Preparing: ") + statement); return false; } String utf8_stmt = ToCharset(CHARSET_UTF8, statement, CHARSET_DEFAULT); if (SQLITE_OK != sqlite3_prepare(db,utf8_stmt,utf8_stmt.GetLength(),¤t_stmt,NULL)) { LLOG("Sqlite3Connection::Compile(" << statement << ") -> error"); session.SetError(sqlite3_errmsg(db), String("Preparing: ") + statement); return false; } current_stmt_string = statement; int nparams = ParseForArgs(current_stmt_string); ASSERT(nparams == param.GetCount()); for (int i = 0; i < nparams; ++i) BindParam(i+1,param[i]); param.Clear(); // Make sure that compiling the statement never fails. ASSERT(NULL != current_stmt); int retcode; dword ticks_start = GetTickCount(); int sleep_ms = 1; do{ retcode = sqlite3_step(current_stmt); if(retcode!=SQLITE_BUSY && retcode!=SQLITE_LOCKED) break; if(session.busy_timeout == 0) break; if(session.busy_timeout>0){ if((int)(GetTickCount()-ticks_start)>session.busy_timeout){ break; } }//else infinite retry if(retcode==SQLITE_LOCKED) sqlite3_reset(current_stmt); Sleep(sleep_ms); if(sleep_ms<128) sleep_ms += sleep_ms; }while(1); if ((retcode != SQLITE_DONE) && (retcode != SQLITE_ROW)) { session.SetError(sqlite3_errmsg(db), current_stmt_string); return false; } got_first_row = got_row_data = (retcode==SQLITE_ROW); // if (got_row_data) { // By WebChaot, 2009-01-15 int numfields = sqlite3_column_count(current_stmt); info.SetCount(numfields); for (int i = 0; i < numfields; ++i) { SqlColumnInfo& field = info[i]; field.name = sqlite3_column_name(current_stmt,i); field.binary = false; String coltype = sqlite3_column_decltype(current_stmt,i); switch (sqlite3_column_type(current_stmt,i)) { case SQLITE_INTEGER: field.type = INT_V; break; case SQLITE_FLOAT: field.type = DOUBLE_V; break; case SQLITE_TEXT: if(coltype == "date") field.type = DATE_V; else if(coltype == "datetime") field.type = TIME_V; else field.type = WSTRING_V; break; case SQLITE_NULL: if(coltype == "date") field.type = DATE_V; else if(coltype == "datetime") field.type = TIME_V; else if(coltype.Find("char") >= 0 || coltype.Find("text") >= 0 ) field.type = WSTRING_V; else if(coltype.Find("integer") >= 0) field.type = INT_V; else if(coltype.Find("real") >= 0) field.type = DOUBLE_V; else field.type = VOID_V; break; case SQLITE_BLOB: field.type = STRING_V; field.binary = true; break; default: NEVER(); break; } } // } return true; }
bool QSQLiteResultPrivate::fetchNext(QSqlCachedResult::ValueCache &values, int idx, bool initialFetch) { int res; int i; if (skipRow) { // already fetched Q_ASSERT(!initialFetch); skipRow = false; for(int i=0;i<firstRow.count();i++) values[i]=firstRow[i]; return skippedStatus; } skipRow = initialFetch; if(initialFetch) { firstRow.clear(); firstRow.resize(sqlite3_column_count(stmt)); } if (!stmt) { q->setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"), QCoreApplication::translate("QSQLiteResult", "No query"), QSqlError::ConnectionError)); q->setAt(QSql::AfterLastRow); return false; } res = sqlite3_step(stmt); switch(res) { case SQLITE_ROW: // check to see if should fill out columns if (rInf.isEmpty()) // must be first call. initColumns(false); if (idx < 0 && !initialFetch) return true; for (i = 0; i < rInf.count(); ++i) { switch (sqlite3_column_type(stmt, i)) { case SQLITE_BLOB: values[i + idx] = QByteArray(static_cast<const char *>( sqlite3_column_blob(stmt, i)), sqlite3_column_bytes(stmt, i)); break; case SQLITE_INTEGER: values[i + idx] = sqlite3_column_int64(stmt, i); break; case SQLITE_FLOAT: switch(q->numericalPrecisionPolicy()) { case QSql::LowPrecisionInt32: values[i + idx] = sqlite3_column_int(stmt, i); break; case QSql::LowPrecisionInt64: values[i + idx] = sqlite3_column_int64(stmt, i); break; case QSql::LowPrecisionDouble: case QSql::HighPrecision: default: values[i + idx] = sqlite3_column_double(stmt, i); break; }; break; case SQLITE_NULL: values[i + idx] = QVariant(QVariant::String); break; default: values[i + idx] = QString(reinterpret_cast<const QChar *>( sqlite3_column_text16(stmt, i)), sqlite3_column_bytes16(stmt, i) / sizeof(QChar)); break; } } return true; case SQLITE_DONE: if (rInf.isEmpty()) // must be first call. initColumns(true); q->setAt(QSql::AfterLastRow); sqlite3_reset(stmt); return false; case SQLITE_CONSTRAINT: case SQLITE_ERROR: // SQLITE_ERROR is a generic error code and we must call sqlite3_reset() // to get the specific error message. res = sqlite3_reset(stmt); q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"), QSqlError::ConnectionError, res)); q->setAt(QSql::AfterLastRow); return false; case SQLITE_MISUSE: case SQLITE_BUSY: default: // something wrong, don't get col info, but still return false q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"), QSqlError::ConnectionError, res)); sqlite3_reset(stmt); q->setAt(QSql::AfterLastRow); return false; } return false; }
void Sqlite3Connection::Reset() { if(current_stmt && sqlite3_reset(current_stmt) != SQLITE_OK) session.SetError(sqlite3_errmsg(db), "Resetting statement: " + current_stmt_string); }
int main(int argc, char **argv){ sqlite3_int64 iBegin; /* Start time of this program */ int quietFlag = 0; /* True if --quiet or -q */ int verboseFlag = 0; /* True if --verbose or -v */ char *zInsSql = 0; /* SQL statement for --load-db or --load-sql */ int iFirstInsArg = 0; /* First argv[] to use for --load-db or --load-sql */ sqlite3 *db = 0; /* The open database connection */ sqlite3_stmt *pStmt; /* A prepared statement */ int rc; /* Result code from SQLite interface calls */ Blob *pSql; /* For looping over SQL scripts */ Blob *pDb; /* For looping over template databases */ int i; /* Loop index for the argv[] loop */ int onlySqlid = -1; /* --sqlid */ int onlyDbid = -1; /* --dbid */ int nativeFlag = 0; /* --native-vfs */ int rebuildFlag = 0; /* --rebuild */ int vdbeLimitFlag = 0; /* --limit-vdbe */ int timeoutTest = 0; /* undocumented --timeout-test flag */ int runFlags = 0; /* Flags sent to runSql() */ char *zMsg = 0; /* Add this message */ int nSrcDb = 0; /* Number of source databases */ char **azSrcDb = 0; /* Array of source database names */ int iSrcDb; /* Loop over all source databases */ int nTest = 0; /* Total number of tests performed */ char *zDbName = ""; /* Appreviated name of a source database */ const char *zFailCode = 0; /* Value of the TEST_FAILURE environment variable */ int cellSzCkFlag = 0; /* --cell-size-check */ int sqlFuzz = 0; /* True for SQL fuzz testing. False for DB fuzz */ int iTimeout = 120; /* Default 120-second timeout */ int nMem = 0; /* Memory limit */ char *zExpDb = 0; /* Write Databases to files in this directory */ char *zExpSql = 0; /* Write SQL to files in this directory */ iBegin = timeOfDay(); #ifdef __unix__ signal(SIGALRM, timeoutHandler); #endif g.zArgv0 = argv[0]; zFailCode = getenv("TEST_FAILURE"); for(i=1; i<argc; i++){ const char *z = argv[i]; if( z[0]=='-' ){ z++; if( z[0]=='-' ) z++; if( strcmp(z,"cell-size-check")==0 ){ cellSzCkFlag = 1; }else if( strcmp(z,"dbid")==0 ){ if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]); onlyDbid = integerValue(argv[++i]); }else if( strcmp(z,"export-db")==0 ){ if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]); zExpDb = argv[++i]; }else if( strcmp(z,"export-sql")==0 ){ if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]); zExpSql = argv[++i]; }else if( strcmp(z,"help")==0 ){ showHelp(); return 0; }else if( strcmp(z,"limit-mem")==0 ){ if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]); nMem = integerValue(argv[++i]); }else if( strcmp(z,"limit-vdbe")==0 ){ vdbeLimitFlag = 1; }else if( strcmp(z,"load-sql")==0 ){ zInsSql = "INSERT INTO xsql(sqltext) VALUES(CAST(readfile(?1) AS text))"; iFirstInsArg = i+1; break; }else if( strcmp(z,"load-db")==0 ){ zInsSql = "INSERT INTO db(dbcontent) VALUES(readfile(?1))"; iFirstInsArg = i+1; break; }else if( strcmp(z,"m")==0 ){ if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]); zMsg = argv[++i]; }else if( strcmp(z,"native-vfs")==0 ){ nativeFlag = 1; }else if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){ quietFlag = 1; verboseFlag = 0; }else if( strcmp(z,"rebuild")==0 ){ rebuildFlag = 1; }else if( strcmp(z,"result-trace")==0 ){ runFlags |= SQL_OUTPUT; }else if( strcmp(z,"sqlid")==0 ){ if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]); onlySqlid = integerValue(argv[++i]); }else if( strcmp(z,"timeout")==0 ){ if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]); iTimeout = integerValue(argv[++i]); }else if( strcmp(z,"timeout-test")==0 ){ timeoutTest = 1; #ifndef __unix__ fatalError("timeout is not available on non-unix systems"); #endif }else if( strcmp(z,"verbose")==0 || strcmp(z,"v")==0 ){ quietFlag = 0; verboseFlag = 1; runFlags |= SQL_TRACE; }else { fatalError("unknown option: %s", argv[i]); } }else{ nSrcDb++; azSrcDb = safe_realloc(azSrcDb, nSrcDb*sizeof(azSrcDb[0])); azSrcDb[nSrcDb-1] = argv[i]; } } if( nSrcDb==0 ) fatalError("no source database specified"); if( nSrcDb>1 ){ if( zMsg ){ fatalError("cannot change the description of more than one database"); } if( zInsSql ){ fatalError("cannot import into more than one database"); } } /* Process each source database separately */ for(iSrcDb=0; iSrcDb<nSrcDb; iSrcDb++){ rc = sqlite3_open(azSrcDb[iSrcDb], &db); if( rc ){ fatalError("cannot open source database %s - %s", azSrcDb[iSrcDb], sqlite3_errmsg(db)); } rc = sqlite3_exec(db, "CREATE TABLE IF NOT EXISTS db(\n" " dbid INTEGER PRIMARY KEY, -- database id\n" " dbcontent BLOB -- database disk file image\n" ");\n" "CREATE TABLE IF NOT EXISTS xsql(\n" " sqlid INTEGER PRIMARY KEY, -- SQL script id\n" " sqltext TEXT -- Text of SQL statements to run\n" ");" "CREATE TABLE IF NOT EXISTS readme(\n" " msg TEXT -- Human-readable description of this file\n" ");", 0, 0, 0); if( rc ) fatalError("cannot create schema: %s", sqlite3_errmsg(db)); if( zMsg ){ char *zSql; zSql = sqlite3_mprintf( "DELETE FROM readme; INSERT INTO readme(msg) VALUES(%Q)", zMsg); rc = sqlite3_exec(db, zSql, 0, 0, 0); sqlite3_free(zSql); if( rc ) fatalError("cannot change description: %s", sqlite3_errmsg(db)); } if( zInsSql ){ sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0, readfileFunc, 0, 0); rc = sqlite3_prepare_v2(db, zInsSql, -1, &pStmt, 0); if( rc ) fatalError("cannot prepare statement [%s]: %s", zInsSql, sqlite3_errmsg(db)); rc = sqlite3_exec(db, "BEGIN", 0, 0, 0); if( rc ) fatalError("cannot start a transaction"); for(i=iFirstInsArg; i<argc; i++){ sqlite3_bind_text(pStmt, 1, argv[i], -1, SQLITE_STATIC); sqlite3_step(pStmt); rc = sqlite3_reset(pStmt); if( rc ) fatalError("insert failed for %s", argv[i]); } sqlite3_finalize(pStmt); rc = sqlite3_exec(db, "COMMIT", 0, 0, 0); if( rc ) fatalError("cannot commit the transaction: %s", sqlite3_errmsg(db)); rebuild_database(db); sqlite3_close(db); return 0; } if( zExpDb!=0 || zExpSql!=0 ){ sqlite3_create_function(db, "writefile", 2, SQLITE_UTF8, 0, writefileFunc, 0, 0); if( zExpDb!=0 ){ const char *zExDb = "SELECT writefile(printf('%s/db%06d.db',?1,dbid),dbcontent)," " dbid, printf('%s/db%06d.db',?1,dbid), length(dbcontent)" " FROM db WHERE ?2<0 OR dbid=?2;"; rc = sqlite3_prepare_v2(db, zExDb, -1, &pStmt, 0); if( rc ) fatalError("cannot prepare statement [%s]: %s", zExDb, sqlite3_errmsg(db)); sqlite3_bind_text64(pStmt, 1, zExpDb, strlen(zExpDb), SQLITE_STATIC, SQLITE_UTF8); sqlite3_bind_int(pStmt, 2, onlyDbid); while( sqlite3_step(pStmt)==SQLITE_ROW ){ printf("write db-%d (%d bytes) into %s\n", sqlite3_column_int(pStmt,1), sqlite3_column_int(pStmt,3), sqlite3_column_text(pStmt,2)); } sqlite3_finalize(pStmt); } if( zExpSql!=0 ){ const char *zExSql = "SELECT writefile(printf('%s/sql%06d.txt',?1,sqlid),sqltext)," " sqlid, printf('%s/sql%06d.txt',?1,sqlid), length(sqltext)" " FROM xsql WHERE ?2<0 OR sqlid=?2;"; rc = sqlite3_prepare_v2(db, zExSql, -1, &pStmt, 0); if( rc ) fatalError("cannot prepare statement [%s]: %s", zExSql, sqlite3_errmsg(db)); sqlite3_bind_text64(pStmt, 1, zExpSql, strlen(zExpSql), SQLITE_STATIC, SQLITE_UTF8); sqlite3_bind_int(pStmt, 2, onlySqlid); while( sqlite3_step(pStmt)==SQLITE_ROW ){ printf("write sql-%d (%d bytes) into %s\n", sqlite3_column_int(pStmt,1), sqlite3_column_int(pStmt,3), sqlite3_column_text(pStmt,2)); } sqlite3_finalize(pStmt); } sqlite3_close(db); return 0; } /* Load all SQL script content and all initial database images from the ** source db */ blobListLoadFromDb(db, "SELECT sqlid, sqltext FROM xsql", onlySqlid, &g.nSql, &g.pFirstSql); if( g.nSql==0 ) fatalError("need at least one SQL script"); blobListLoadFromDb(db, "SELECT dbid, dbcontent FROM db", onlyDbid, &g.nDb, &g.pFirstDb); if( g.nDb==0 ){ g.pFirstDb = safe_realloc(0, sizeof(Blob)); memset(g.pFirstDb, 0, sizeof(Blob)); g.pFirstDb->id = 1; g.pFirstDb->seq = 0; g.nDb = 1; sqlFuzz = 1; } /* Print the description, if there is one */ if( !quietFlag ){ int i; zDbName = azSrcDb[iSrcDb]; i = strlen(zDbName) - 1; while( i>0 && zDbName[i-1]!='/' && zDbName[i-1]!='\\' ){ i--; } zDbName += i; sqlite3_prepare_v2(db, "SELECT msg FROM readme", -1, &pStmt, 0); if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){ printf("%s: %s\n", zDbName, sqlite3_column_text(pStmt,0)); } sqlite3_finalize(pStmt); } /* Rebuild the database, if requested */ if( rebuildFlag ){ if( !quietFlag ){ printf("%s: rebuilding... ", zDbName); fflush(stdout); } rebuild_database(db); if( !quietFlag ) printf("done\n"); } /* Close the source database. Verify that no SQLite memory allocations are ** outstanding. */ sqlite3_close(db); if( sqlite3_memory_used()>0 ){ fatalError("SQLite has memory in use before the start of testing"); } /* Limit available memory, if requested */ if( nMem>0 ){ void *pHeap; sqlite3_shutdown(); pHeap = malloc(nMem); if( pHeap==0 ){ fatalError("failed to allocate %d bytes of heap memory", nMem); } sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nMem, 128); } /* Register the in-memory virtual filesystem */ formatVfs(); inmemVfsRegister(); /* Run a test using each SQL script against each database. */ if( !verboseFlag && !quietFlag ) printf("%s:", zDbName); for(pSql=g.pFirstSql; pSql; pSql=pSql->pNext){ for(pDb=g.pFirstDb; pDb; pDb=pDb->pNext){ int openFlags; const char *zVfs = "inmem"; sqlite3_snprintf(sizeof(g.zTestName), g.zTestName, "sqlid=%d,dbid=%d", pSql->id, pDb->id); if( verboseFlag ){ printf("%s\n", g.zTestName); fflush(stdout); }else if( !quietFlag ){ static int prevAmt = -1; int idx = pSql->seq*g.nDb + pDb->id - 1; int amt = idx*10/(g.nDb*g.nSql); if( amt!=prevAmt ){ printf(" %d%%", amt*10); fflush(stdout); prevAmt = amt; } } createVFile("main.db", pDb->sz, pDb->a); openFlags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE; if( nativeFlag && pDb->sz==0 ){ openFlags |= SQLITE_OPEN_MEMORY; zVfs = 0; } rc = sqlite3_open_v2("main.db", &db, openFlags, zVfs); if( rc ) fatalError("cannot open inmem database"); #ifdef SQLITE_ENABLE_JSON1 { extern int sqlite3_json_init(sqlite3*); sqlite3_json_init(db); } #endif if( cellSzCkFlag ) runSql(db, "PRAGMA cell_size_check=ON", runFlags); setAlarm(iTimeout); #ifndef SQLITE_OMIT_PROGRESS_CALLBACK if( sqlFuzz || vdbeLimitFlag ){ sqlite3_progress_handler(db, 100000, progressHandler, &vdbeLimitFlag); } #endif do{ runSql(db, (char*)pSql->a, runFlags); }while( timeoutTest ); setAlarm(0); sqlite3_close(db); if( sqlite3_memory_used()>0 ) fatalError("memory leak"); reformatVfs(); nTest++; g.zTestName[0] = 0; /* Simulate an error if the TEST_FAILURE environment variable is "5". ** This is used to verify that automated test script really do spot ** errors that occur in this test program. */ if( zFailCode ){ if( zFailCode[0]=='5' && zFailCode[1]==0 ){ fatalError("simulated failure"); }else if( zFailCode[0]!=0 ){ /* If TEST_FAILURE is something other than 5, just exit the test ** early */ printf("\nExit early due to TEST_FAILURE being set\n"); iSrcDb = nSrcDb-1; goto sourcedb_cleanup; } } } } if( !quietFlag && !verboseFlag ){ printf(" 100%% - %d tests\n", g.nDb*g.nSql); } /* Clean up at the end of processing a single source database */ sourcedb_cleanup: blobListFree(g.pFirstSql); blobListFree(g.pFirstDb); reformatVfs(); } /* End loop over all source databases */ if( !quietFlag ){ sqlite3_int64 iElapse = timeOfDay() - iBegin; printf("fuzzcheck: 0 errors out of %d tests in %d.%03d seconds\n" "SQLite %s %s\n", nTest, (int)(iElapse/1000), (int)(iElapse%1000), sqlite3_libversion(), sqlite3_sourceid()); } free(azSrcDb); return 0; }
int statement::reset() { return sqlite3_reset(stmt_); }
void Statement::reset() { assert(impl); sqlite3_reset(impl->stmt); }
static int import(const char *szTableName, const char *szImportFileName, const char *szRecordSeparator) { sqlite3_stmt *pStmt = NULL; int nCol; int i, j; char *zLine; char **azCol; char *zCommit; FILE *pFileIn; int lineno = 0; int nSep = strlen30(szRecordSeparator); if(0 == nSep) { LOG("Error: non-null separator required for import."); return BWLIST_ERROR; } char *SqlString = sqlite3_mprintf("SELECT * FROM %s", szTableName); if(NULL == SqlString) { LOG("Error: out of memory."); return BWLIST_ERROR; } int nByte = strlen30(SqlString); sqlite3_mutex_enter(db_mutex); int rc = sqlite3_prepare_v2(db, SqlString, -1, &pStmt, 0); sqlite3_free(SqlString); SqlString = NULL; if( rc ) { sqlite3_finalize(pStmt); sqlite3_mutex_leave(db_mutex); LOG("Error: %s.", sqlite3_errmsg(db)); return BWLIST_ERROR; } sqlite3_mutex_leave(db_mutex); nCol = sqlite3_column_count(pStmt); sqlite3_finalize(pStmt); pStmt = NULL; if(0 == nCol) { return BWLIST_OK; /* no columns, no error */ } SqlString = malloc( nByte + 20 + nCol*2 ); if(NULL == SqlString) { LOG("Error: out of memory!."); return BWLIST_ERROR; } sqlite3_snprintf(nByte+20, SqlString, "INSERT INTO %s VALUES(?", szTableName); j = strlen30(SqlString); for(i = 1; i < nCol; i++) { SqlString[j++] = ','; SqlString[j++] = '?'; } SqlString[j++] = ')'; SqlString[j] = 0; sqlite3_mutex_enter(db_mutex); rc = sqlite3_prepare_v2(db, SqlString, -1, &pStmt, 0); free(SqlString); SqlString = NULL; if(rc) { LOG("Error: %s.", sqlite3_errmsg(db)); sqlite3_finalize(pStmt); sqlite3_mutex_leave(db_mutex); return BWLIST_ERROR; } sqlite3_mutex_leave(db_mutex); pFileIn = fopen(szImportFileName, "rb"); if( pFileIn==0 ) { LOG("Error: cannot open \"%s\".", szImportFileName); sqlite3_finalize(pStmt); return BWLIST_ERROR; } azCol = malloc(sizeof(azCol[0])*(nCol+1) ); if( azCol==0 ) { LOG("Error: out of memory."); fclose(pFileIn); sqlite3_finalize(pStmt); return BWLIST_ERROR; } sqlite3_mutex_enter(db_mutex); //BEGIN IMMEDIATE avoid deadlock if (SQLITE_OK != sqlite3_exec(db, "BEGIN IMMEDIATE", 0, 0, 0)) { LOG("BEGIN TRANSACTION Error:%s", sqlite3_errmsg(db)); fclose(pFileIn); sqlite3_mutex_leave(db_mutex); sqlite3_finalize(pStmt); return BWLIST_ERROR; } sqlite3_mutex_leave(db_mutex); zCommit = "COMMIT"; while( (zLine = local_getline(pFileIn, 1))!=0 ) { char *z, c; int inQuote = 0; lineno++; azCol[0] = zLine; for(i=0, z=zLine; (c = *z)!=0; z++) { if(c=='"') { inQuote = !inQuote; } if(c=='\n') { lineno++; } if(!inQuote && c==szRecordSeparator[0] && strncmp(z,szRecordSeparator,nSep)==0) { *z = 0; i++; if(i<nCol) { azCol[i] = &z[nSep]; z += nSep-1; } } } /* end for */ *z = 0; if( i+1!=nCol ) { LOG("Error: %s line %d: expected %d columns of data bud found %d.", szImportFileName, lineno, nCol, i+1); zCommit = "ROLLBACK"; free(zLine); rc = 1; break; /* from while */ } for(i=0; i<nCol; i++) { if( azCol[i][0]=='"' ) { int k; for(z=azCol[i], j=1, k=0; z[j]; j++) { if( z[j]=='"' ) { j++; if(z[j]==0) { break; } } z[k++] = z[j]; } z[k] = 0; } sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC); } sqlite3_mutex_enter(db_mutex); sqlite3_step(pStmt); rc = sqlite3_reset(pStmt); free(zLine); //if(rc!=SQLITE_OK) //SQLITE_CONSTRAINT: abort due to constraint violation if (SQLITE_OK != rc && SQLITE_CONSTRAINT != rc) { LOG("Error:%s", sqlite3_errmsg(db)); sqlite3_mutex_leave(db_mutex); zCommit = "ROLLBACK"; rc = 1; break; /* from while */ } sqlite3_mutex_leave(db_mutex); } /* end while */ free(azCol); fclose(pFileIn); sqlite3_finalize(pStmt); if (sqlite3_exec(db, zCommit, 0, 0, 0) != SQLITE_OK) { return BWLIST_ERROR; } if (strcmp(zCommit, "COMMIT") == 0) { return BWLIST_OK; } else { return BWLIST_ERROR; } }
static int OGR2SQLITEDealWithSpatialColumn(OGRLayer* poLayer, int iGeomCol, const LayerDesc& oLayerDesc, const CPLString& osTableName, OGRSQLiteDataSource* poSQLiteDS, sqlite3* hDB, int bSpatialiteDB, const std::set<LayerDesc>& WHEN_SPATIALITE(oSetLayers), const std::set<CPLString>& WHEN_SPATIALITE(oSetSpatialIndex) ) { OGRGeomFieldDefn* poGeomField = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeomCol); CPLString osGeomColRaw; if( iGeomCol == 0 ) osGeomColRaw = OGR2SQLITE_GetNameForGeometryColumn(poLayer); else osGeomColRaw = poGeomField->GetNameRef(); const char* pszGeomColRaw = osGeomColRaw.c_str(); CPLString osGeomColEscaped(OGRSQLiteEscape(pszGeomColRaw)); const char* pszGeomColEscaped = osGeomColEscaped.c_str(); CPLString osLayerNameEscaped(OGRSQLiteEscape(osTableName)); const char* pszLayerNameEscaped = osLayerNameEscaped.c_str(); CPLString osIdxNameRaw(CPLSPrintf("idx_%s_%s", oLayerDesc.osLayerName.c_str(), pszGeomColRaw)); CPLString osIdxNameEscaped(OGRSQLiteEscapeName(osIdxNameRaw)); /* Make sure that the SRS is injected in spatial_ref_sys */ OGRSpatialReference* poSRS = poGeomField->GetSpatialRef(); if( iGeomCol == 0 && poSRS == NULL ) poSRS = poLayer->GetSpatialRef(); int nSRSId = poSQLiteDS->GetUndefinedSRID(); if( poSRS != NULL ) nSRSId = poSQLiteDS->FetchSRSId(poSRS); CPLString osSQL; #ifdef HAVE_SPATIALITE bool bCreateSpatialIndex = false; #endif if( !bSpatialiteDB ) { osSQL.Printf("INSERT INTO geometry_columns (f_table_name, " "f_geometry_column, geometry_format, geometry_type, " "coord_dimension, srid) " "VALUES ('%s','%s','SpatiaLite',%d,%d,%d)", pszLayerNameEscaped, pszGeomColEscaped, (int) wkbFlatten(poLayer->GetGeomType()), wkbHasZ( poLayer->GetGeomType() ) ? 3 : 2, nSRSId); } #ifdef HAVE_SPATIALITE else { /* We detect the need for creating a spatial index by 2 means : */ /* 1) if there's an explicit reference to a 'idx_layername_geometrycolumn' */ /* table in the SQL --> old/traditionnal way of requesting spatial indices */ /* with spatialite. */ std::set<LayerDesc>::const_iterator oIter2 = oSetLayers.begin(); for(; oIter2 != oSetLayers.end(); ++oIter2) { const LayerDesc& oLayerDescIter = *oIter2; if( EQUAL(oLayerDescIter.osLayerName, osIdxNameRaw) ) { bCreateSpatialIndex = true; break; } } /* 2) or if there's a SELECT FROM SpatialIndex WHERE f_table_name = 'layername' */ if( !bCreateSpatialIndex ) { std::set<CPLString>::const_iterator oIter3 = oSetSpatialIndex.begin(); for(; oIter3 != oSetSpatialIndex.end(); ++oIter3) { const CPLString& osNameIter = *oIter3; if( EQUAL(osNameIter, oLayerDesc.osLayerName) ) { bCreateSpatialIndex = true; break; } } } if( poSQLiteDS->HasSpatialite4Layout() ) { int nGeomType = poLayer->GetGeomType(); int nCoordDimension = 2; if( wkbHasZ((OGRwkbGeometryType)nGeomType) ) { nGeomType += 1000; nCoordDimension = 3; } osSQL.Printf("INSERT INTO geometry_columns (f_table_name, " "f_geometry_column, geometry_type, coord_dimension, " "srid, spatial_index_enabled) " "VALUES ('%s',Lower('%s'),%d ,%d ,%d, %d)", pszLayerNameEscaped, pszGeomColEscaped, nGeomType, nCoordDimension, nSRSId, bCreateSpatialIndex ); } else { const char *pszGeometryType = OGRToOGCGeomType(poLayer->GetGeomType()); if (pszGeometryType[0] == '\0') pszGeometryType = "GEOMETRY"; osSQL.Printf("INSERT INTO geometry_columns (f_table_name, " "f_geometry_column, type, coord_dimension, " "srid, spatial_index_enabled) " "VALUES ('%s','%s','%s','%s',%d, %d)", pszLayerNameEscaped, pszGeomColEscaped, pszGeometryType, wkbHasZ( poLayer->GetGeomType() ) ? "XYZ" : "XY", nSRSId, bCreateSpatialIndex ); } } #endif // HAVE_SPATIALITE int rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL ); #ifdef HAVE_SPATIALITE /* -------------------------------------------------------------------- */ /* Should we create a spatial index ?. */ /* -------------------------------------------------------------------- */ if( !bSpatialiteDB || !bCreateSpatialIndex ) return rc == SQLITE_OK; CPLDebug("SQLITE", "Create spatial index %s", osIdxNameRaw.c_str()); /* ENABLE_VIRTUAL_OGR_SPATIAL_INDEX is not defined */ #ifdef ENABLE_VIRTUAL_OGR_SPATIAL_INDEX osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" USING " "VirtualOGRSpatialIndex(%d, '%s', pkid, xmin, xmax, ymin, ymax)", osIdxNameEscaped.c_str(), nExtraDS, OGRSQLiteEscape(oLayerDesc.osLayerName).c_str()); rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL ); if( rc != SQLITE_OK ) { CPLDebug("SQLITE", "Error occured during spatial index creation : %s", sqlite3_errmsg(hDB)); } #else // ENABLE_VIRTUAL_OGR_SPATIAL_INDEX rc = sqlite3_exec( hDB, "BEGIN", NULL, NULL, NULL ); osSQL.Printf("CREATE VIRTUAL TABLE \"%s\" " "USING rtree(pkid, xmin, xmax, ymin, ymax)", osIdxNameEscaped.c_str()); if( rc == SQLITE_OK ) rc = sqlite3_exec( hDB, osSQL.c_str(), NULL, NULL, NULL ); sqlite3_stmt *hStmt = NULL; if( rc == SQLITE_OK ) { const char* pszInsertInto = CPLSPrintf( "INSERT INTO \"%s\" (pkid, xmin, xmax, ymin, ymax) " "VALUES (?,?,?,?,?)", osIdxNameEscaped.c_str()); rc = sqlite3_prepare(hDB, pszInsertInto, -1, &hStmt, NULL); } OGRFeature* poFeature; OGREnvelope sEnvelope; OGR2SQLITE_IgnoreAllFieldsExceptGeometry(poLayer); poLayer->ResetReading(); while( rc == SQLITE_OK && (poFeature = poLayer->GetNextFeature()) != NULL ) { OGRGeometry* poGeom = poFeature->GetGeometryRef(); if( poGeom != NULL && !poGeom->IsEmpty() ) { poGeom->getEnvelope(&sEnvelope); sqlite3_bind_int64(hStmt, 1, (sqlite3_int64) poFeature->GetFID() ); sqlite3_bind_double(hStmt, 2, sEnvelope.MinX); sqlite3_bind_double(hStmt, 3, sEnvelope.MaxX); sqlite3_bind_double(hStmt, 4, sEnvelope.MinY); sqlite3_bind_double(hStmt, 5, sEnvelope.MaxY); rc = sqlite3_step(hStmt); if( rc == SQLITE_OK || rc == SQLITE_DONE ) rc = sqlite3_reset(hStmt); } delete poFeature; } poLayer->SetIgnoredFields(NULL); sqlite3_finalize(hStmt); if( rc == SQLITE_OK ) rc = sqlite3_exec( hDB, "COMMIT", NULL, NULL, NULL ); else { CPLDebug("SQLITE", "Error occured during spatial index creation : %s", sqlite3_errmsg(hDB)); rc = sqlite3_exec( hDB, "ROLLBACK", NULL, NULL, NULL ); } #endif // ENABLE_VIRTUAL_OGR_SPATIAL_INDEX #endif // HAVE_SPATIALITE return rc == SQLITE_OK; }
bool QgsOracleTableCache::saveToCache( const QString& connName, CacheFlags flags, const QVector<QgsOracleLayerProperty>& layers ) { sqlite3* db = _openCacheDatabase(); if ( !db ) return false; QString tblNameRaw = "oracle_" + connName; QString tblName = QgsOracleConn::quotedIdentifier( tblNameRaw ); // recreate the cache table if ( !_removeFromCache( db, connName ) ) { sqlite3_close( db ); return false; } QString sqlCreateTable = QString( "CREATE TABLE %1 (ownername text, tablename text, geometrycolname text, isview int, sql text, pkcols text, geomtypes text, geomsrids text)" ).arg( tblName ); QString sqlInsertToMeta = QString( "INSERT INTO meta_oracle VALUES (%1, %2)" ).arg( QgsOracleConn::quotedValue( connName ) ).arg(( int ) flags ); bool res1 = _executeSqliteStatement( db, sqlCreateTable ); bool res2 = _executeSqliteStatement( db, sqlInsertToMeta ); if ( !res1 || !res2 ) { sqlite3_close( db ); return false; } // insert data _executeSqliteStatement( db, "BEGIN" ); QString sqlInsert = QString( "INSERT INTO %1 VALUES(?,?,?,?,?,?,?,?)" ).arg( tblName ); sqlite3_stmt* stmtInsert; if ( sqlite3_prepare_v2( db, sqlInsert.toUtf8().data(), -1, &stmtInsert, 0 ) != SQLITE_OK ) { sqlite3_close( db ); return false; } bool insertOk = true; Q_FOREACH ( const QgsOracleLayerProperty& item, layers ) { sqlite3_bind_text( stmtInsert, 1, item.ownerName.toUtf8().data(), -1, SQLITE_TRANSIENT ); sqlite3_bind_text( stmtInsert, 2, item.tableName.toUtf8().data(), -1, SQLITE_TRANSIENT ); sqlite3_bind_text( stmtInsert, 3, item.geometryColName.toUtf8().data(), -1, SQLITE_TRANSIENT ); sqlite3_bind_int( stmtInsert, 4, item.isView ); sqlite3_bind_text( stmtInsert, 5, item.sql.toUtf8().data(), -1, SQLITE_TRANSIENT ); sqlite3_bind_text( stmtInsert, 6, item.pkCols.join( "," ).toUtf8().data(), -1, SQLITE_TRANSIENT ); QStringList geomTypes; Q_FOREACH ( QGis::WkbType geomType, item.types ) geomTypes.append( QString::number( static_cast<ulong>( geomType ) ) ); sqlite3_bind_text( stmtInsert, 7, geomTypes.join( "," ).toUtf8().data(), -1, SQLITE_TRANSIENT ); QStringList geomSrids; Q_FOREACH ( int geomSrid, item.srids ) geomSrids.append( QString::number( geomSrid ) ); sqlite3_bind_text( stmtInsert, 8, geomSrids.join( "," ).toUtf8().data(), -1, SQLITE_TRANSIENT ); if ( sqlite3_step( stmtInsert ) != SQLITE_DONE ) insertOk = false; sqlite3_reset( stmtInsert ); }
/* * TOUCHATAG_SQLITE3_ADD dato un tag e un azione, se il tag non è nel db lo mette nel db con l'azione voluta e ritorna 1. altrimenti non fa niente e ritorna 0; se errore -1 */ int touchatag_sqlite3_add (tag_t *tag, char *act) { sqlite3_stmt *pStmt; sqlite3 *database; int rc, rf, i = 0; char *pa = act; uid[14]='\0'; data[96]='\0'; if ((rc = sqlite3_open (dbname, &database)) != SQLITE_OK){ printf ("Error sqlite3_open ()\n"); return -1; } touchatag_sconvert (tag, uid, data); if ((rf = touchatag_taglist_sqlite3_search (tag)) == -1){ printf ("Error touchatag_taglist_sqlite3_search ()\n"); sqlite3_close (database); return -1; } if (rf == 0) { if ((rc = sqlite3_prepare_v2 (database, "INSERT INTO tag VALUES (?,?,?,0,NULL)", -1, &pStmt, NULL)) != SQLITE_OK){ printf ("Error sqlite3_prepare_v2 ()\n"); sqlite3_close (database); return -1; } if ((rc = sqlite3_bind_text (pStmt, 1, (const char*) uid, -1, NULL)) != SQLITE_OK){ printf ("Error sqlite3_bind_text () #1\n"); sqlite3_close (database); return -1; } if ((rc = sqlite3_bind_text (pStmt, 2, (const char*) data, -1, NULL)) != SQLITE_OK){ printf ("Error sqlite3_bind_text () #2\n"); sqlite3_close (database); return -1; } if ((rc = sqlite3_bind_text (pStmt, 3, (const char*) pa, -1, NULL)) != SQLITE_OK){ printf ("Error sqlite3_bind_text () #3\n"); sqlite3_close (database); return -1; } } if (rf == 1) { sqlite3_close (database); return 0; } if ((rc = sqlite3_step (pStmt)) != SQLITE_DONE){ printf ("Error sqlite3_step ()\n"); sqlite3_close (database); return -1; } i = sqlite3_clear_bindings (pStmt); if ((rc = sqlite3_reset (pStmt))!= SQLITE_OK){ printf ("Errore sqlite3_reset ()\n"); sqlite3_close (database); return -1; } sqlite3_close (database); return 1; }
void SQLiteHandler::select(char* sql) { pStmt = NULL; sqlite3_prepare_v2(db, sql, strlen(sql), &pStmt, NULL); sqlite3_reset(pStmt); }
/*! * Saves for each photon all the data, except previous and next photon identifier. */ void PhotonMapExportDB::SaveNotNextPrevID( std::vector< Photon* > raysLists ) { const char* tail = 0; sqlite3_stmt* stmt; char insertSQL[256] ="\0"; sprintf( insertSQL, "INSERT INTO Photons VALUES( @id, @x, @y, @z, @side, @surfaceID )" ); sqlite3_prepare( m_pDB, insertSQL, 256, &stmt, &tail ); char* sErrMsg = 0; sqlite3_exec( m_pDB, "BEGIN TRANSACTION", 0, 0, &sErrMsg ); unsigned long nPhotonElements = raysLists.size(); if( m_saveCoordinatesInGlobal ) { for( unsigned int i = 0; i < nPhotonElements; i++ ) { Photon* photon = raysLists[i]; sqlite3_bind_text( stmt, 1, QString::number(++m_exportedPhoton ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); //m_saveCoordinates Point3D photonPos = m_concentratorToWorld( photon->pos ); sqlite3_bind_text( stmt, 2, QString::number( photonPos.x ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); sqlite3_bind_text( stmt, 3, QString::number( photonPos.y ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); sqlite3_bind_text( stmt, 4, QString::number( photonPos.z ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); //m_saveSide sqlite3_bind_text( stmt, 5, QString::number( photon->side ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); //m_saveSurfaceID unsigned long urlId = 0; if( photon->intersectedSurface ) { if( !m_surfaceIdentfier.contains( photon->intersectedSurface ) ) InsertSurface( photon->intersectedSurface ); urlId = m_surfaceIdentfier.indexOf( photon->intersectedSurface ) + 1; } sqlite3_bind_text( stmt, 6, QString::number( urlId ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); sqlite3_step( stmt ); sqlite3_clear_bindings( stmt ); sqlite3_reset( stmt ); } } else { for( unsigned int i = 0; i < nPhotonElements; i++ ) { std::stringstream ss; Photon* photon = raysLists[i]; unsigned long urlId = 0; Transform worldToObject( 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0 ); if( photon->intersectedSurface ) { if( !m_surfaceIdentfier.contains( photon->intersectedSurface ) ) InsertSurface( photon->intersectedSurface ); urlId = m_surfaceIdentfier.indexOf( photon->intersectedSurface ) ; worldToObject = m_surfaceWorldToObject[urlId]; urlId++; } sqlite3_bind_text( stmt, 1, QString::number(++m_exportedPhoton ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); //m_saveCoordinates Point3D localPos = worldToObject( photon->pos ); sqlite3_bind_text( stmt, 2, QString::number( localPos.x ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); sqlite3_bind_text( stmt, 3, QString::number( localPos.y ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); sqlite3_bind_text( stmt, 4, QString::number( localPos.z ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); //m_saveSide sqlite3_bind_text( stmt, 5, QString::number( photon->side ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); //m_saveSurfaceID sqlite3_bind_text( stmt, 6, QString::number( urlId ).toStdString().c_str(), -1, SQLITE_TRANSIENT ); sqlite3_step( stmt ); sqlite3_clear_bindings( stmt ); sqlite3_reset( stmt ); } } int rc = sqlite3_exec( m_pDB, "END TRANSACTION", 0, 0, &sErrMsg ); sqlite3_finalize( stmt ); if( rc != SQLITE_OK ) { std::cout<< "SQL error: "<<sErrMsg<<"\n"<<std::endl; sqlite3_free( sErrMsg ); } }
void resetParameter(DbAction *db) { if (db -> statement[0] != 0) sqlite3_reset(db -> sqlStatement); //sqlite3_clear_bindings(db -> sqlStatement); }