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

int DbLastRowId(DB_HANDLE handle, DB_ID* id){    if (id == NULL) {        return MsgLog(DBS_INVARG, "NULL id");    }    /* TODO returns a sqlite_int64; can this be cast into an unsigned long?     * do we need to check this for each platform? */	*id = (DB_ID) sqlite3_last_insert_rowid((sqlite3*) handle);	/*	 * In sqlite, there is no error code; a value of 0 is returned if there	 * is no matching row.  In this case, convert it to an error code.	 */	return (*id != 0) ? 0 : DBS_NOSUCHROW;}

int RollbackManager::getNodeId(const std::string &name){	for (std::vector<Entity>::const_iterator iter = knownNodes.begin();			iter != knownNodes.end(); ++iter) {		if (iter->name == name) {			return iter->id;		}	}	SQLOK(sqlite3_bind_text(stmt_knownNode_insert, 1, name.c_str(), name.size(), NULL));	SQLRES(sqlite3_step(stmt_knownNode_insert), SQLITE_DONE);	SQLOK(sqlite3_reset(stmt_knownNode_insert));	int id = sqlite3_last_insert_rowid(db);	registerNewNode(id, name);	return id;}

Replacements::Replacements(sqlite3* db, string name, sqlite_int64 ownerId) :    mDb(db), mName(name), mOwnerId(ownerId){    exAssert(db!=NULL);    exAssertDesc(ownerId > 0, "ownerId should be greater null");	sqlite_int64 groupId = 0;	stringstream strSql;	strSql  << "SELECT rowid FROM replacementGroups "		<< "WHERE name = " << cSqlStrOut(mName)		<< " AND ownerId = " << mOwnerId;	string sRowId;	exec(strSql, mDb, onReadFirstField, &sRowId);	if (sRowId.length() > 0) {		groupId = cSqlInFormated<sqlite_int64>(sRowId);	} else {		strSql.str(""); //clear		strSql  << "INSERT INTO replacementGroups "			<< "(name, ownerId) VALUES ("			<< cSqlStrOut(mName) << ", "			<< mOwnerId << ")";		exec(strSql, mDb);		groupId = sqlite3_last_insert_rowid(mDb);	}	vector<string> rowids;	strSql.str(""); //clear	strSql << "SELECT rowid FROM replacements "		"WHERE groupId = " << cSqlOutFormated(groupId) ;	exec(strSql, db, onAppendFirstColumnToVector, &rowids);	for (vector<string>::iterator it = rowids.begin();		it != rowids.end(); it++) {			stringstream strRowid(*it);			sqlite_int64 rowid;			strRowid >> rowid;			Replacement* newReplacement = new Replacement(db,  rowid);			mChildren[newReplacement->getRowId()] = newReplacement;	}};

void PsmFile::insertMatches(const vector<Match>& matches){    // insert the result into tables msRunSearchResult, BiblioSpecSearchResult    char zSql[2048];    double pValue = -1;    for(int i = 0; i < reportMatches_; i++) {        Match tmpMatch = matches.at(i);        const RefSpectrum* tmpRefSpec = tmpMatch.getRefSpec();        //        const Spectrum* s = tmpMatch.getExpSpec();       pValue = -1 * log(tmpMatch.getScore(BONF_PVAL));        if(isinf( pValue ))            pValue = 1000;        sprintf(zSql,                "insert into msRunSearchResult(runSearchID,scanID,charge,"                "peptide,preResidue, postResidue, validationStatus) "                "values(%d,%d,%d,'%s','%s','%s','=')",                blibRunSearchID_,                0,//                s->getScanID(),                0,//tmpRefSpec->getCharge(),                (tmpRefSpec->getSeq()).c_str(),                (tmpRefSpec->getPrevAA()).c_str(),                (tmpRefSpec->getNextAA()).c_str());        SqliteRoutine::SQL_STMT(zSql, db_);                zSql[0]='/0';                int resultID=(int)sqlite3_last_insert_rowid(db_);        sprintf(zSql, "insert into BiblioSpecSearchResult "                "values(%d,%d,%d,%d,%f,%f,'%s')",                resultID,                tmpRefSpec->getLibSpecID(),                tmpMatch.getMatchLibID(),                i+1,                tmpMatch.getScore(DOTP),                pValue,                tmpRefSpec->getMods().c_str());        SqliteRoutine::SQL_STMT(zSql, db_);        zSql[0]='/0';    } // next match}

void Cache::addVCard(const std::string &fn, const std::string &ln, const std::vector< std::string > &emails, const std::string &data, const std::string &updatedAt) {    if(fn.length() == 0) {        std::cerr << "Firstname is empty!" << std::endl;        return;    }    if(ln.length() == 0) {        std::cerr << "Lastname is empty!" << std::endl;        return;    }    if(emails.size() == 0) {        std::cerr << "Email is empty!" << std::endl;        return;    }    if(data.length() == 0) {        std::cerr << "Data is empty!" << std::endl;        return;    }    if(db == NULL) {        std::cerr << "Database not open!" << std::endl;        return;    }    std::string dt = buildDateTimeString(updatedAt);    std::stringstream ss;    // happy sql injecting ;)    ss << "insert into vcards (FirstName, LastName, VCard, UpdatedAt) values (";    ss << "'" << fn << "','" << ln << "','" << data << "','" << dt << "')";    bool b = prepSqlite(ss.str());    if(b) {        b = stepSqlite("Failed to add new record to cache database");        if(b) {            sqlite3_int64 rowid = sqlite3_last_insert_rowid(db);            addEmails(emails, rowid);        } else {            finalizeSqlite(); // finalize on error only        }    }}

sqlite_int64find_album_art(const char * path, const char * image_data, int image_size){	char * album_art = NULL;	char * sql;	char ** result;	int cols, rows;	sqlite_int64 ret = 0;	char * mypath;	const char * dir;	struct stat st;	if( stat(path, &st) == 0 && S_ISDIR(st.st_mode) )	{		mypath = NULL;		dir = path;	}	else	{		mypath = strdup(path);		dir = dirname(mypath);	}	if( (image_size && (album_art = check_embedded_art(path, image_data, image_size))) ||	    (album_art = check_for_album_file(dir, path)) )	{		sql = sqlite3_mprintf("SELECT ID from ALBUM_ART where PATH = '%q'", album_art ? album_art : path);		if( (sql_get_table(db, sql, &result, &rows, &cols) == SQLITE_OK) && rows )		{			ret = strtoll(result[1], NULL, 10);		}		else		{			if( sql_exec(db, "INSERT into ALBUM_ART (PATH) VALUES ('%q')", album_art) == SQLITE_OK )				ret = sqlite3_last_insert_rowid(db);		}		sqlite3_free_table(result);		sqlite3_free(sql);	}	free(album_art);	free(mypath);	return ret;}

static int linphone_chat_message_store_content(LinphoneChatMessage *msg) {	LinphoneCore *lc = linphone_chat_room_get_core(msg->chat_room);	int id = -1;	if (lc->db) {		LinphoneContent *content = msg->file_transfer_information;		char *buf = sqlite3_mprintf("INSERT INTO content VALUES(NULL,%Q,%Q,%Q,%Q,%i,%Q);",						linphone_content_get_type(content),						linphone_content_get_subtype(content),						linphone_content_get_name(content),						linphone_content_get_encoding(content),						linphone_content_get_size(content),						NULL					);		linphone_sql_request(lc->db, buf);		sqlite3_free(buf);		id = (unsigned int) sqlite3_last_insert_rowid (lc->db);	}	return id;}

u32 DBH_RegisterUser( char* nUsername, char* nPassword ){  u32 uid = 0;  if ( DBH_UserExistsByName( nUsername ) ) return uid;  char* pQueryString = malloc( 128 );  memset( pQueryString, 0, 128 );  sprintf( pQueryString, "INSERT INTO Users (username, password) VALUES ('%s', '%s')", nUsername, nPassword );  DBH_Query( pQueryString, NULL, NULL, NULL );  free( pQueryString );  // assumes a maximum user id of 2^32  uid = (u32) sqlite3_last_insert_rowid( DBH_dbhnd );  return uid;}

int64_t library_image_add(int64_t file){  static const char *sql =    "INSERT INTO images (fileid) VALUES(?)";    sqlite3_stmt *query;    if (!prepare_query(sql, &query)) {    return -1;  }    sqlite3_bind_int64(query, 1, file);    if (!execute(query)) {    return -1;  }    return sqlite3_last_insert_rowid(db_handle());}

int main(void) {        sqlite3 *db;    char *err_msg = 0;        int rc = sqlite3_open(":memory:", &db);        if (rc != SQLITE_OK) {                fprintf(stderr, "Cannot open database: %s/n", sqlite3_errmsg(db));        sqlite3_close(db);                return 1;    }        char *sql = "CREATE TABLE Friends(Id INTEGER PRIMARY KEY, Name TEXT);"    "INSERT INTO Friends(Name) VALUES ('Tom');"    "INSERT INTO Friends(Name) VALUES ('Rebecca');"    "INSERT INTO Friends(Name) VALUES ('Jim');"    "INSERT INTO Friends(Name) VALUES ('Roger');"    "INSERT INTO Friends(Name) VALUES ('Robert');";                rc = sqlite3_exec(db, sql, 0, 0, &err_msg);        if (rc != SQLITE_OK ) {                fprintf(stderr, "Failed to create table/n");        fprintf(stderr, "SQL error: %s/n", err_msg);        sqlite3_free(err_msg);            } else {                fprintf(stdout, "Table Friends created successfully/n");    }        int last_id = sqlite3_last_insert_rowid(db);    printf("The last Id of the inserted row is %d/n", last_id);    sqlite3_close(db);        return 0;}

/** * This method is susceptible to injections. Please make sure filename is 'safe' */uint32_t db_wrapper::insert_file(std::string filename) {    {	sqlite3_stmt *ppStmt;	char sql[1024] = "/0";	sprintf(sql, "select fileId from files where filename like '%s'", filename.c_str());	if (SQLITE_OK != sqlite3_prepare_v2(db, sql, -1, &ppStmt, 0)) {	    std::cout << "Well here's an error (3)..." << std::endl;	    //error handling	}	uint32_t fileId = 0;	if (sqlite3_step(ppStmt) != SQLITE_DONE) {	    fileId = sqlite3_column_int(ppStmt,0);	    sqlite3_finalize(ppStmt);	    return fileId;	}	sqlite3_finalize(ppStmt);    }    sqlite3_stmt *ppStmt;    char sql[1024] = "/0";    sprintf(sql, "insert into files (filename) VALUES ('%s')", filename.c_str());    if (SQLITE_OK != sqlite3_prepare_v2(db, sql, -1, &ppStmt, 0)) {	std::cout << "Well here's an error (4)..." << std::endl;	//error handling    }    uint32_t fileId = 0;    int rc;    if (SQLITE_DONE != (rc = sqlite3_step(ppStmt))) {    	// error handling    	std::cout << "something went wrong. Error code: " << rc << std::endl;    	std::cout << sqlite3_errmsg(db) << std::endl;    }    fileId = sqlite3_last_insert_rowid(db);    sqlite3_finalize(ppStmt);    return fileId;}

Sender * DB::addSender(Sender &snd){	int res;	SQLOK(bind_text(stmt_add_sender, 1, snd.nick.data(), snd.nick.size(),			NULL), "binding sender nick");	SQLOK(bind_text(stmt_add_sender, 2, snd.user.data(), snd.user.size(),			NULL), "binding sender ident");	SQLOK(bind_text(stmt_add_sender, 3, snd.host.data(), snd.host.size(),			NULL), "binding sender host");	SQLRES(step(stmt_add_sender), SQLITE_DONE,			"running sender insertion statement");	SQLOK(reset(stmt_add_sender),			"reseting sender insertion statement");	snd.id = sqlite3_last_insert_rowid(dbh);	senders.push_back(snd);	return &senders[senders.size() - 1];}

static krb5_error_codecreate_cache(krb5_context context, krb5_scache *s){    int ret;    sqlite3_bind_text(s->icache, 1, s->name, -1, NULL);    do {	ret = sqlite3_step(s->icache);    } while (ret == SQLITE_ROW);    if (ret != SQLITE_DONE) {	krb5_set_error_message(context, KRB5_CC_IO,			       N_("Failed to add scache: %d", ""), ret);	return KRB5_CC_IO;    }    sqlite3_reset(s->icache);    s->cid = sqlite3_last_insert_rowid(s->db);    return 0;}

uint64_t EventLogger::logEvent(ExecutionState *state, unsigned event,            uint64_t count) {    void *host_callstack[32];    sqlite3_bind_int(event_insert_stmt_, 1, event);    sqlite3_bind_int64(event_insert_stmt_, 2, count);    if (!CollectHostBacktraces) {        sqlite3_bind_null(event_insert_stmt_, 3);    } else {        int btrace_size = backtrace(&host_callstack[0], 32);        sqlite3_bind_blob(event_insert_stmt_, 3, &host_callstack[0],                btrace_size * sizeof(void*), NULL);    }    int result = sqlite3_step(event_insert_stmt_);    assert(result == SQLITE_DONE);    sqlite3_reset(event_insert_stmt_);    return sqlite3_last_insert_rowid(db_);}

int insert_peerProfile(const char *nick_name, const char *group_name, const char *sex, const char *age, const char *introduction, const char *head_image_path, const char *server_id, const char *server_uid, const char *last_ip, const char *tcp_port, const char *udp_port){	char *errmsg=0;//记录返回的错误信息。	sqlite3 *db=0; //记录返回的数据库句柄	if(!open_db(&db, PEERSINFO_DBFILE_NAME))		return false;	// 下述函数进行数据库添加操作	char *szBaseSql = "insert into peers_profile(nick_name,group_name,sex,age,introduction,head_image_path,server_id,server_uid,last_ip,last_tcp_port,last_udp_port) values('";	char *szSql = v6strcat(23, szBaseSql, nick_name, "','", group_name, "','", sex, "','",age, "','",introduction, "','",head_image_path, "','",server_id, "','",server_uid, "','",last_ip, "','",tcp_port, "','",udp_port,"')");	int rc=sqlite3_exec(db,szSql,0,0,&errmsg);	release_db_data((void **)&szSql);	CHECK_RC(rc,errmsg,db);	// 下述函数获取数据库插入的数据的ID	int id = (int) sqlite3_last_insert_rowid(db);	sqlite3_close(db);	return id;}

int insert_myProfile(const char *name,const char *sex,const char *age,const char *introduction,const char *head_image_path, const char *v4_port, const char *v6_port){	char *errmsg=0;//记录返回的错误信息。	sqlite3 *db=0; //记录返回的数据库句柄	if(!open_db(&db, MYINFO_DBFILE_NAME))		return false;	//下述函数进行数据库添加操作	char *szBaseSql = "insert into my_profile(nick_name,sex,age,introduction,head_image_path,v4_port,v6_port) values('";	char *szSql = v6strcat(15, szBaseSql, name, "','", sex, "','", age, "','",introduction,"','",head_image_path,"','",v4_port,"','",v6_port,"')");	int rc=sqlite3_exec(db,szSql,0,0,&errmsg);	release_db_data((void **)&szSql);	CHECK_RC(rc,errmsg,db);	//下述函数获取数据库插入的数据的ID	int id = (int) sqlite3_last_insert_rowid(db);	sqlite3_close(db);	return id;}

int insert_serverInformation(const char *name, const char *ip, const char *port, const char *description, const char *uid, const char *upassword){	char *errmsg=0;//记录返回的错误信息。	sqlite3 *db=0; //记录返回的数据库句柄	if(!open_db(&db, SERVERSINFO_DBFILE_NAME))		return false;	//下述函数进行数据库添加操作	char *szBaseSql = "insert into server_information(name,ip,port,description,uid,upassword) values('";	char *szSql = v6strcat(13, szBaseSql, name, "','", ip, "','", port, "','",description, "','",uid, "','",upassword,"')");	int rc=sqlite3_exec(db,szSql,0,0,&errmsg);	release_db_data((void **)&szSql);	CHECK_RC(rc,errmsg,db);	//下述函数获取数据库插入的数据的ID	int id = (int) sqlite3_last_insert_rowid(db);	sqlite3_close(db);	return id;}

// insert and return parameter's idint database_handler::insert_parameter(const char* parameter_name, int error_id) {    char* error_message = NULL;    std::stringstream s_url_id;    std::string stmt;    s_url_id << error_id;    stmt += "INSERT INTO PARAMETERS (PARAMETER_NAME, ERROR_ID) VALUES('";    stmt += parameter_name;    stmt += "',";    stmt += s_url_id.str();    stmt += ");";    sqlite3_exec(db, stmt.c_str(), NULL, 0, &error_message);    if (error_message) {        std::cout << error_message << std::endl;        sqlite3_free(error_message);        return -1;    }    return sqlite3_last_insert_rowid(db);}

sqlite3_int64 createecu(sqlite3 *db, const char *vin, long ecu, const char *ecudesc) {	sqlite3_int64 foundecu = getecuid(db, vin, ecu);	if(0 < foundecu) {		return foundecu;	}	char insert_sql[] = "INSERT INTO ecu (vin,ecu,ecudesc) VALUES (?,?,?)";	int rc;	sqlite3_stmt *stmt;	rc = sqlite3_prepare_v2(db, insert_sql, -1, &stmt, NULL);	if(SQLITE_OK != rc) {		fprintf(stderr, "Can't prepare statement %s: %s/n", insert_sql, sqlite3_errmsg(db));		return -1;	}	if(NULL != vin) {		sqlite3_bind_text(stmt, 1, vin, strlen(vin), NULL);	} else {		sqlite3_bind_text(stmt, 1, "", 0, NULL);	}	sqlite3_bind_int64(stmt, 2, ecu);	if(NULL != ecudesc) {		sqlite3_bind_text(stmt, 3, ecudesc, strlen(ecudesc), NULL);	} else {		sqlite3_bind_text(stmt, 3, "", 0, NULL);	}	rc = sqlite3_step(stmt);	if(SQLITE_OK != rc && SQLITE_DONE != rc) {		fprintf(stderr, "Error stepping ecu insert(%i): %s/n", rc, sqlite3_errmsg(db));	}	sqlite3_finalize(stmt);	return sqlite3_last_insert_rowid(db);}

PRIVATE void create_batch(int format_index, int key_prov_index, int min_lenght, int max_lenght, const char* provider_param){	sqlite3_stmt* insert_new_batch;	free(batch);	num_attack_in_batch = 1;	current_attack_index = 0;	batch = (AttackData*)malloc( sizeof(AttackData) * num_attack_in_batch);	batch[0].format_index = format_index;	batch[0].provider_index = key_prov_index;	// Check that lengths are in range	batch[0].min_lenght = __min(__max(__min(max_lenght, min_lenght), key_providers[batch[0].provider_index].min_size), formats[batch[0].format_index].max_plaintext_lenght);	batch[0].max_lenght = __min(max_lenght, formats[batch[0].format_index].max_plaintext_lenght);	batch[0].num_keys_served = 0;	// Put Params	strcpy(batch[0].params, provider_param);	sprintf(batch_name, "%s / %s", formats[format_index].name, key_providers[key_prov_index].name);	sprintf(batch_description, "Length %i - %i", batch[0].min_lenght, batch[0].max_lenght);	key_providers[key_prov_index].get_param_description(provider_param, batch_name+strlen(batch_name), batch[0].min_lenght, batch[0].max_lenght);	batch[0].resume_arg[0] = 0;	// Method to split charset into optimized chunks	introduce_fast_lm(&batch, &num_attack_in_batch);	// Insert batch data	if(!is_benchmark)	{		sqlite3_prepare_v2(db, "INSERT INTO Batch (Name,Description) VALUES (?,?);", -1, &insert_new_batch, NULL);		sqlite3_bind_text(insert_new_batch, 1, batch_name, -1, SQLITE_STATIC);		sqlite3_bind_text(insert_new_batch, 2, batch_description, -1, SQLITE_STATIC);		sqlite3_step(insert_new_batch);		batch_db_id = sqlite3_last_insert_rowid(db);		sqlite3_finalize(insert_new_batch);	}}

/** * Add a new part to the current tarif. * * @param   hour The starting hour. * @param   min The starting minute. * @param   days The days it applies. * @param   hourprice The price per hour. * @return The tarifpart's id. */gintCCL_tarifpart_new(guint hour, guint min, guint days, guint hourprice, guint incprice){  gchar *cmd = NULL;  sqlite3_stmt *stmt = NULL;  g_return_val_if_fail(-1 == CCL_tarifpart_id_get(hour, min, days), -1);  g_return_val_if_fail(!CCL_tarifpart_conflicts(hour, min, days, NULL), -1);  g_return_val_if_fail(days <= 127 && days, -1);  g_return_val_if_fail(1 <= ccl->tarif_id, -1);  cmd = sqlite3_mprintf("insert into tarifs/n"			"(tarif, days, stime, hourprice, incprice)/n"			"values(%d, %u, '%.2u:%.2u', %u, %u);",			ccl->tarif_id, days, hour, min, hourprice, incprice);  sqlite3_prepare(ccl->db, cmd, -1, &stmt, NULL);  sqlite3_free(cmd);  sqlite3_step(stmt);  sqlite3_finalize(stmt);  return sqlite3_last_insert_rowid(ccl->db);}

bool BRCWriter::Insert(std::string symName, int type, sqlite3_int64 *id){    static char *query = "INSERT INTO Names (name, type) VALUES (?,?)";    int rc = SQLITE_OK;    static sqlite3_stmt *handle;    if (!handle)    {        rc = sqlite3_prepare_v2(dbPointer, query, strlen(query)+1, &handle, nullptr);    }    if (rc == SQLITE_OK)    {        int done = false;        sqlite3_reset(handle);        sqlite3_bind_text(handle, 1, symName.c_str(), symName.size(), SQLITE_STATIC);        sqlite3_bind_int(handle, 2, type);        while (!done)        {            switch(rc = sqlite3_step(handle))            {                case SQLITE_BUSY:                    done = true;                    break;                case SQLITE_DONE:                    rc = SQLITE_OK;                    done = true;                    break;                default:                    done = true;                    break;            }        }                            }    if (rc == SQLITE_OK)    {        *id = sqlite3_last_insert_rowid(dbPointer);    }    return rc == SQLITE_OK;}

static int _insert_ud(struct meas_db_state *st, unsigned long meas_id, int dtx,		      int uplink, const struct gsm_meas_rep_unidir *ud){	unsigned long rowid;	SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_ud, 1, meas_id));	SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_ud, 2,					rxlev2dbm(ud->full.rx_lev)));	SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_ud, 3,					rxlev2dbm(ud->sub.rx_lev)));	SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_ud, 4, ud->full.rx_qual));	SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_ud, 5, ud->sub.rx_qual));	SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_ud, 6, dtx));	SCK_OK(st->db, sqlite3_bind_int(st->stmt_ins_ud, 7, uplink));	SCK_DONE(st->db, sqlite3_step(st->stmt_ins_ud));	SCK_OK(st->db, sqlite3_reset(st->stmt_ins_ud));	return sqlite3_last_insert_rowid(st->db);err_io:	exit(1);}

int DBBrowserDB::addRecord(const QString& sTableName){    char *errmsg;    if (!isOpen()) return false;    // add record is seldom called, for now this is ok    // but if we ever going to add a lot of records    // we should cache the parsed tables somewhere    sqlb::Table table = sqlb::Table::parseSQL(getObjectByName(sTableName).getsql()).first;    QString sInsertstmt = table.emptyInsertStmt();    lastErrorMessage = "";    logSQL(sInsertstmt, kLogMsg_App);    setRestorePoint();    if (SQLITE_OK != sqlite3_exec(_db, sInsertstmt.toUtf8(), NULL, NULL, &errmsg))    {        lastErrorMessage = QString::fromUtf8(errmsg);        qWarning() << "addRecord: " << lastErrorMessage;        return -1;    } else {        return sqlite3_last_insert_rowid(_db);    }}

int db_insertTeacher(sqlite3 * db, char * name, double rate, int subjects, int years, char * birthdate){    sqlite3_stmt * stmt =  NULL;    int last = -1;    const char * sql = "INSERT INTO Teachers (name, rate, subjects, years, birthdate) VALUES (?, ?, ?, ?, ?);";    int rc = sqlite3_prepare_v2(db, sql, strlen(sql), &stmt, NULL);    sqlite3_bind_text(stmt, 1, name, strlen(name), SQLITE_TRANSIENT);    sqlite3_bind_double(stmt, 2, rate);    sqlite3_bind_int(stmt, 3, subjects);    sqlite3_bind_int(stmt, 4, years);    sqlite3_bind_text(stmt, 5, birthdate, strlen(birthdate), SQLITE_TRANSIENT);    if(SQLITE_OK != rc)    {        printf("Not prepared!/n");    }    if (SQLITE_DONE != (rc = sqlite3_step(stmt)))    {        printf("Not inserted! %i/n", rc);    }    last = (int) sqlite3_last_insert_rowid (db);    sqlite3_finalize(stmt);    return last; }

int64_tPibDb::addCertificate(const IdentityCertificate& certificate){  const Name& certName = certificate.getName();  const Name& keyName = certificate.getPublicKeyName();  if (!hasKey(keyName))    addKey(keyName, certificate.getPublicKeyInfo());  sqlite3_stmt* statement;  sqlite3_prepare_v2(m_database,                     "INSERT INTO certificates /                      (key_id, certificate_name, certificate_data) /                      values ((SELECT id FROM keys WHERE key_name=?), ?, ?)",                     -1, &statement, nullptr);  sqlite3_bind_block(statement, 1, keyName.wireEncode(), SQLITE_TRANSIENT);  sqlite3_bind_block(statement, 2, certName.wireEncode(), SQLITE_TRANSIENT);  sqlite3_bind_block(statement, 3, certificate.wireEncode(), SQLITE_STATIC);  sqlite3_step(statement);  sqlite3_finalize(statement);  return sqlite3_last_insert_rowid(m_database);}

int DocumentDatabase::insert(sqlite3* db, std::string q){	char* errorMessage;	sqlite3_exec(db, q.c_str(), NULL, NULL, &errorMessage);	if (errorMessage)	{		std::cout << "Error executing the following SQL command" << std::endl;		std::cout << q << std::endl;		std::cout << "Error message:" << errorMessage;		sqlite3_free(errorMessage);	}	int ret = (int)sqlite3_last_insert_rowid(db);	return ret;	//sqlite3_stmt* stmt;	//std::stringstream b;	//b << q;	//std::string s = b.str();	//char *str = &s[0];	//int result;	//char *query = str;	//{	//	int prepCode = sqlite3_prepare(db, query, -1, &stmt, 0);	//	if (prepCode == SQLITE_OK)	//	{	//		int res = sqlite3_step(stmt);	//		result = res;	//		sqlite3_finalize(stmt);	//	}	//	else	//	{	//		std::cout << "Error executing the following SQL command" << std::endl;	//		std::cout << q << std::endl;	//		std::cout << "Error Code:" << prepCode;	//	}	//}	}

int update_peerProfile(const char *uid, const char *nick_name, const char *group_name, const char *sex, const char *age, const char *introduction, const char *head_image_path, const char *server_id, const char *server_uid, const char *last_ip, const char *tcp_port, const char *udp_port){	char *errmsg=0;//记录返回的错误信息。	sqlite3 *db=0; //记录返回的数据库句柄	if(!open_db(&db, PEERSINFO_DBFILE_NAME))		return false;	// 替换introduction字段中'为''	char* newintro = replacestr(introduction, "'", "''");	//下述函数进行数据库添加操作	int id = atoi(uid);	char *szSql = NULL;	if(id == 0)	{	    char *szBaseSql = "insert into peers_profile(nick_name,group_name,sex,age,introduction,head_image_path,server_id,server_uid,last_ip,last_tcp_port,last_udp_port) values('";	    szSql = v6strcat(23, szBaseSql, nick_name, "','", group_name, "','", sex, "','",age, "','",newintro, "','",head_image_path, "','",server_id, "','",server_uid, "','",last_ip, "','",tcp_port, "','",udp_port,"')");	}	else	{		char *szBaseSql = "insert or replace into peers_profile(uid,nick_name,group_name,sex,age,introduction,head_image_path,server_id,server_uid,last_ip,last_tcp_port,last_udp_port) values('";	    szSql = v6strcat(25, szBaseSql, uid, "','", nick_name, "','", group_name, "','", sex, "','",age, "','",newintro, "','",head_image_path, "','",server_id, "','",server_uid, "','",last_ip, "','",tcp_port, "','",udp_port,"')");	}	int rc=sqlite3_exec(db,szSql,0,0,&errmsg);	release_db_data((void **)&szSql);	free(newintro);	CHECK_RC(rc,errmsg,db);	//下述函数获取数据库插入的数据的ID	if(id == 0)	    id = (int) sqlite3_last_insert_rowid(db);	sqlite3_close(db);	return id;}

__int64 database::add_order(const ::TradeGateway::Order *pOrder){	if( !this->is_connected() )		this->connect();	std::ostringstream sql;	sql << "INSERT INTO dt_orders VALUES ("		<< "'" << pOrder->accountId << "',"		<< "'" << pOrder->inst.securityID << "',"		<< ""  << pOrder->inst.securityIDSource<< ","		<< ""  << pOrder->s << ","		<< ""  << pOrder->posEfct << ","		<< ""  << pOrder->type<< ","		<< ""  << pOrder->lmtPrice<< ","		<< ""  << pOrder->ordQty << ","		<< "'" << pOrder->ordId<< "',"		<< ""  << TradeGateway::New << ","		<< ""  << pOrder->date<< ","		<< ""  << pOrder->time<< ","		<< ""  << 0<< ","		<< ""  << 0<< ","		<< ""  << pOrder->ordQty<< ","		<< "/"" << ""<< "/");";		char *zErrMsg = 0;	int rc = sqlite3_exec(pdb, sql.str().c_str(), NULL, 0, &zErrMsg);	if( rc!=SQLITE_OK )	{		std::ostringstream err ;		err << "SQL error: " << zErrMsg;		sqlite3_free(zErrMsg);		throw err.str();	}	else		return sqlite3_last_insert_rowid( pdb );}