自学教程：C++ sqlite3_reset函数代码示例

static mrb_valuemrb_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*/inttouchatag_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*/inttouchatag_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)//.........这里部分代码省略.........

void RepoStmt::reset() {  sqlite3_reset(m_stmt);  sqlite3_clear_bindings(m_stmt);}

DWORDSamDbDeleteObject(    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);    }//.........这里部分代码省略.........

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;	}//.........这里部分代码省略.........

int machine_reset(Pointer stmt) {  reset_ready_event( EV_Done| EV_Data | EV_Error);	return msg_id(sqlite3_reset((sqlite3_stmt*)stmt));}

static mrb_valuemrb_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(),&current_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);}

//.........这里部分代码省略.........    }    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 ){

void Statement::reset() {    assert(impl);    sqlite3_reset(impl->stmt);}

//.........这里部分代码省略.........    }    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;    }}

//.........这里部分代码省略.........            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*/inttouchatag_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 );//.........这里部分代码省略.........

void resetParameter(DbAction *db){	if (db -> statement[0] != 0)	sqlite3_reset(db -> sqlStatement);	//sqlite3_clear_bindings(db -> sqlStatement);}