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

int main() {	Five arr[50000];	int idx = 0;	FILE * fp;	char * line = NULL;	size_t len = 0;	size_t read;	int begin = stampstart();	fp = fopen("50000.csv", "r");	if (fp == NULL) {		exit(EXIT_FAILURE);	}	char* buf = (char*)malloc(sizeof(char)*128);	while((read = getline(&line, &len, fp)) != -1) {		Five five;		five.firstname = (char*)malloc(sizeof(char)*128);		five.lastname = (char*)malloc(sizeof(char)*128);		five.company = (char*)malloc(sizeof(char)*128);		five.road = (char*)malloc(sizeof(char)*128);		five.city = (char*)malloc(sizeof(char)*128);		five.state = (char*)malloc(sizeof(char)*128);		five.stateaka = (char*)malloc(sizeof(char)*128);		five.telefon = (char*)malloc(sizeof(char)*128);		five.fax = (char*)malloc(sizeof(char)*128);		five.email = (char*)malloc(sizeof(char)*128);		five.web = (char*)malloc(sizeof(char)*128);		int r = sscanf(line, "%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],/"%[^,],%[^,],%[^,],%[^,],%[^,]/n",			five.firstname, five.lastname, five.company, five.road, five.city, five.state, five.stateaka, 			buf, five.telefon, five.fax, five.email, five.web);		five.zip = atoi(buf);		five.firstname = five.firstname+1;		five.firstname[strlen(five.firstname)-1] = '/0';		five.lastname = five.lastname+1;		five.lastname[strlen(five.lastname)-1] = '/0';		five.company = five.company+1;		five.company[strlen(five.company)-1] = '/0';		five.road = five.road+1;		five.road[strlen(five.road)-1] = '/0';		five.city = five.city+1;		five.city[strlen(five.city)-1] = '/0';		five.state = five.state+1;		five.state[strlen(five.state)-1] = '/0';		five.stateaka = five.stateaka+1;		five.stateaka[strlen(five.stateaka)-1] = '/0';		five.telefon = five.telefon+1;		five.telefon[strlen(five.telefon)-1] = '/0';		five.fax = five.fax+1;		five.fax[strlen(five.fax)-1] = '/0';		five.email = five.email+1;		five.email[strlen(five.email)-1] = '/0';		five.web = five.web+1;		five.web[strlen(five.web)-1] = '/0';		if(r != 12) {			printf("%d %s/n", r, line);			return 1;		}		arr[idx++] = five;	}	free(buf);	if (line) {		free(line);	}	//printf("csv time %d/n", stampstop(begin));	begin = stampstart();	sqlite3 *db;	int ret = sqlite3_open("testtable.db",&db);	assert(ret == SQLITE_OK);	//gettimeofday(&start, NULL);	ret = sqlite3_exec(db, "BEGIN TRANSACTION;", NULL, NULL, NULL);	assert(ret == SQLITE_OK);	const char* istmt  = "INSERT INTO Person(Firstname, Lastname, Company, Address, County, City, State, Zip, PhoneWork, PhonePrivat, Mail, Www) Values(?,?,?,?,?,?,?,?,?,?,?,?);";	//const char* istmt2  = "INSERT INTO Person(Firstname, Lastname, Company, Address, County, City, State, Zip, PhoneWork, PhonePrivat, Mail, Www) Values(%s,%s,%s,%s,%s,%s,%s,%d,%s,%s,%s,%s);/n";	sqlite3_stmt* stmt;	const char* ozTest;	ret = sqlite3_prepare_v2(db, istmt, strlen(istmt), &stmt, &ozTest);	assert(ret == SQLITE_OK);	for(int i = 0; i < idx; ++i) {		int j = 1;		/*printf(istmt2, arr[i].firstname, arr[i].lastname, 			arr[i].company, arr[i].road, arr[i].city, arr[i].state, arr[i].stateaka, arr[i].zip, 			arr[i].telefon, arr[i].fax, arr[i].email, arr[i].web		);*/		sqlite3_bind_text(stmt, j++, arr[i].firstname, strlen(arr[i].firstname), NULL);		sqlite3_bind_text(stmt, j++, arr[i].lastname, strlen(arr[i].lastname), NULL);		sqlite3_bind_text(stmt, j++, arr[i].company, strlen(arr[i].company), NULL);		sqlite3_bind_text(stmt, j++, arr[i].road, strlen(arr[i].road), NULL);		sqlite3_bind_text(stmt, j++, arr[i].city, strlen(arr[i].city), NULL);		sqlite3_bind_text(stmt, j++, arr[i].state, strlen(arr[i].state), NULL);		sqlite3_bind_text(stmt, j++, arr[i].stateaka, strlen(arr[i].stateaka), NULL);		sqlite3_bind_int(stmt, j++, arr[i].zip);		sqlite3_bind_text(stmt, j++, arr[i].telefon, strlen(arr[i].telefon), NULL);		sqlite3_bind_text(stmt, j++, arr[i].fax, strlen(arr[i].fax), NULL);		sqlite3_bind_text(stmt, j++, arr[i].email, strlen(arr[i].email), NULL);		sqlite3_bind_text(stmt, j++, arr[i].web, strlen(arr[i].web), NULL);		assert(j == 13);		ret = sqlite3_step(stmt);//.........这里部分代码省略.........

static tb_bool_t tb_database_sqlite3_statement_bind(tb_database_sql_impl_t* database, tb_database_sql_statement_ref_t statement, tb_database_sql_value_t const* list, tb_size_t size){    // check    tb_database_sqlite3_t* sqlite = tb_database_sqlite3_cast(database);    tb_assert_and_check_return_val(sqlite && sqlite->database && statement && list && size, tb_false);    // the param count    tb_size_t param_count = (tb_size_t)sqlite3_bind_parameter_count((sqlite3_stmt*)statement);    tb_assert_and_check_return_val(size == param_count, tb_false);       // walk    tb_size_t i = 0;    for (i = 0; i < size; i++)    {        // the value        tb_database_sql_value_t const* value = &list[i];        // done        tb_int_t    ok = SQLITE_ERROR;        tb_byte_t*  data = tb_null;        switch (value->type)        {        case TB_DATABASE_SQL_VALUE_TYPE_TEXT:            tb_trace_i("sqlite3: test %lu %s", i, value->u.text.data);            ok = sqlite3_bind_text((sqlite3_stmt*)statement, (tb_int_t)(i + 1), value->u.text.data, (tb_int_t)tb_database_sql_value_size(value), tb_null);            break;        case TB_DATABASE_SQL_VALUE_TYPE_INT64:        case TB_DATABASE_SQL_VALUE_TYPE_UINT64:            ok = sqlite3_bind_int64((sqlite3_stmt*)statement, (tb_int_t)(i + 1), tb_database_sql_value_int64(value));            break;        case TB_DATABASE_SQL_VALUE_TYPE_INT32:        case TB_DATABASE_SQL_VALUE_TYPE_INT16:        case TB_DATABASE_SQL_VALUE_TYPE_INT8:        case TB_DATABASE_SQL_VALUE_TYPE_UINT32:        case TB_DATABASE_SQL_VALUE_TYPE_UINT16:        case TB_DATABASE_SQL_VALUE_TYPE_UINT8:            ok = sqlite3_bind_int((sqlite3_stmt*)statement, (tb_int_t)(i + 1), (tb_int_t)tb_database_sql_value_int32(value));            break;        case TB_DATABASE_SQL_VALUE_TYPE_BLOB16:        case TB_DATABASE_SQL_VALUE_TYPE_BLOB8:            ok = sqlite3_bind_blob((sqlite3_stmt*)statement, (tb_int_t)(i + 1), value->u.blob.data, (tb_int_t)value->u.blob.size, tb_null);            break;        case TB_DATABASE_SQL_VALUE_TYPE_BLOB32:            {                if (value->u.blob.stream)                {                    // done                    do                    {                        // the stream size                        tb_hong_t size = tb_stream_size(value->u.blob.stream);                        tb_assert_and_check_break(size >= 0);                        // make data                        data = tb_malloc0_bytes((tb_size_t)size);                        tb_assert_and_check_break(data);                        // read data                        if (!tb_stream_bread(value->u.blob.stream, data, (tb_size_t)size)) break;                        // bind it                        ok = sqlite3_bind_blob((sqlite3_stmt*)statement, (tb_int_t)(i + 1), data, (tb_int_t)size, tb_database_sqlite3_statement_bind_exit);                    } while (0);                }                else ok = sqlite3_bind_blob((sqlite3_stmt*)statement, (tb_int_t)(i + 1), value->u.blob.data, (tb_int_t)value->u.blob.size, tb_null);            }            break;#ifdef TB_CONFIG_TYPE_HAVE_FLOAT        case TB_DATABASE_SQL_VALUE_TYPE_FLOAT:        case TB_DATABASE_SQL_VALUE_TYPE_DOUBLE:            ok = sqlite3_bind_double((sqlite3_stmt*)statement, (tb_int_t)(i + 1), (tb_double_t)tb_database_sql_value_double(value));            break;#endif        case TB_DATABASE_SQL_VALUE_TYPE_NULL:            ok = sqlite3_bind_null((sqlite3_stmt*)statement, (tb_int_t)(i + 1));            break;        default:            tb_trace_e("statement: bind: unknown value type: %lu", value->type);            break;        }        // failed?        if (SQLITE_OK != ok)        {            // exit data            if (data) tb_free(data);            data = tb_null;            // save state            sqlite->base.state = tb_database_sqlite3_state_from_errno(sqlite3_errcode(sqlite->database));            // trace            tb_trace_e("statement: bind value[%lu] failed, error[%d]: %s", i, sqlite3_errcode(sqlite->database), sqlite3_errmsg(sqlite->database));            break;        }    }    // ok?    return (i == size)? tb_true : tb_false;//.........这里部分代码省略.........

 int statement::bind(int idx, char const* value, bool fstatic) {   return sqlite3_bind_text(stmt_, idx, value, std::strlen(value), fstatic ? SQLITE_STATIC : SQLITE_TRANSIENT); }

//.........这里部分代码省略.........    QString myFileName = myFileInfo.path() + QDir::separator() + myFileInfo.completeBaseName() + ".qml";    QFile myFile( myFileName );    if ( myFile.open( QFile::WriteOnly | QFile::Truncate ) )    {      QTextStream myFileStream( &myFile );      // save as utf-8 with 2 spaces for indents      myDocument.save( myFileStream, 2 );      myFile.close();      theResultFlag = true;      return tr( "Created default style file as %1" ).arg( myFileName );    }    else    {      theResultFlag = false;      return tr( "ERROR: Failed to created default style file as %1. Check file permissions and retry." ).arg( myFileName );    }  }  else  {    QString qml = myDocument.toString();    // read from database    sqlite3 *myDatabase;    sqlite3_stmt *myPreparedStatement;    const char *myTail;    int myResult;    myResult = sqlite3_open( QDir( QgsApplication::qgisSettingsDirPath() ).absoluteFilePath( "qgis.qmldb" ).toUtf8().data(), &myDatabase );    if ( myResult != SQLITE_OK )    {      return tr( "User database could not be opened." );    }    QByteArray param0 = theURI.toUtf8();    QByteArray param1 = qml.toUtf8();    QString mySql = "create table if not exists tbl_styles(style varchar primary key,qml varchar)";    myResult = sqlite3_prepare( myDatabase, mySql.toUtf8().data(), mySql.toUtf8().length(), &myPreparedStatement, &myTail );    if ( myResult == SQLITE_OK )    {      if ( sqlite3_step( myPreparedStatement ) != SQLITE_DONE )      {        sqlite3_finalize( myPreparedStatement );        sqlite3_close( myDatabase );        theResultFlag = false;        return tr( "The style table could not be created." );      }    }    sqlite3_finalize( myPreparedStatement );    mySql = "insert into tbl_styles(style,qml) values (?,?)";    myResult = sqlite3_prepare( myDatabase, mySql.toUtf8().data(), mySql.toUtf8().length(), &myPreparedStatement, &myTail );    if ( myResult == SQLITE_OK )    {      if ( sqlite3_bind_text( myPreparedStatement, 1, param0.data(), param0.length(), SQLITE_STATIC ) == SQLITE_OK &&           sqlite3_bind_text( myPreparedStatement, 2, param1.data(), param1.length(), SQLITE_STATIC ) == SQLITE_OK &&           sqlite3_step( myPreparedStatement ) == SQLITE_DONE )      {        theResultFlag = true;        myErrorMessage = tr( "The style %1 was saved to database" ).arg( theURI );      }    }    sqlite3_finalize( myPreparedStatement );    if ( !theResultFlag )    {      QString mySql = "update tbl_styles set qml=? where style=?";      myResult = sqlite3_prepare( myDatabase, mySql.toUtf8().data(), mySql.toUtf8().length(), &myPreparedStatement, &myTail );      if ( myResult == SQLITE_OK )      {        if ( sqlite3_bind_text( myPreparedStatement, 2, param0.data(), param0.length(), SQLITE_STATIC ) == SQLITE_OK &&             sqlite3_bind_text( myPreparedStatement, 1, param1.data(), param1.length(), SQLITE_STATIC ) == SQLITE_OK &&             sqlite3_step( myPreparedStatement ) == SQLITE_DONE )        {          theResultFlag = true;          myErrorMessage = tr( "The style %1 was updated in the database." ).arg( theURI );        }        else        {          theResultFlag = false;          myErrorMessage = tr( "The style %1 could not be updated in the database." ).arg( theURI );        }      }      else      {        theResultFlag = false;        myErrorMessage = tr( "The style %1 could not be inserted into database." ).arg( theURI );      }      sqlite3_finalize( myPreparedStatement );    }    sqlite3_close( myDatabase );  }  return myErrorMessage;}

void Binder::bind(std::size_t pos, const std::string& val){	int rc = sqlite3_bind_text(_pStmt, (int) pos, val.c_str(), (int) val.size()*sizeof(char), SQLITE_TRANSIENT);	checkReturn(rc);}

 Statement& bind_text(const std::string& value) {     if (SQLITE_OK != sqlite3_bind_text(m_statement, m_bindnum++, value.c_str(), -1, SQLITE_STATIC)) {         throw Sqlite::Exception("Can't bind text value", m_db.errmsg());     }     return *this; }

bool index_lookup_identifier(const char *identifier, id_sub_type sub_type){   bool retval = true;   sqlite3_stmt *stmt_lookup_identifier;   int result;   switch (sub_type)   {      default:      case IST_REFERENCE:      {         result = sqlite3_prepare_v2(cpd.index,                                     "SELECT Files.Filename,Refs.Line,Refs.ColumnStart,Refs.Scope,Refs.Type,Refs.Identifier "                                     "FROM Files JOIN Refs ON Files.rowid=Refs.Filerow "                                     "WHERE Refs.Identifier GLOB ?",                                     -1,                                     &stmt_lookup_identifier,                                     NULL);         break;      }      case IST_DEFINITION:      {         result = sqlite3_prepare_v2(cpd.index,                                     "SELECT Files.Filename,Defs.Line,Defs.ColumnStart,Defs.Scope,Defs.Type,Defs.Identifier "                                     "FROM Files JOIN Defs ON Files.rowid=Defs.Filerow "                                     "WHERE Defs.Identifier GLOB ?",                                     -1,                                     &stmt_lookup_identifier,                                     NULL);         break;      }      case IST_DECLARATION:      {         result = sqlite3_prepare_v2(cpd.index,                                     "SELECT Files.Filename,Decls.Line,Decls.ColumnStart,Decls.Scope,Decls.Type,Decls.Identifier "                                     "FROM Files JOIN Decls ON Files.rowid=Decls.Filerow "                                     "WHERE Decls.Identifier GLOB ?",                                     -1,                                     &stmt_lookup_identifier,                                     NULL);         break;      }   }   if (result == SQLITE_OK)   {      result = sqlite3_bind_text(stmt_lookup_identifier,                                 1,                                 identifier != NULL ? identifier : "%",                                 -1,                                 SQLITE_STATIC);   }   if (result == SQLITE_OK)   {      do      {         result = sqlite3_step(stmt_lookup_identifier);         if (result == SQLITE_ROW)         {            const char *filename = reinterpret_cast<const char*>(sqlite3_column_text(stmt_lookup_identifier, 0));            UINT32 line = (UINT32) sqlite3_column_int64(stmt_lookup_identifier, 1);            UINT32 column_start = (UINT32) sqlite3_column_int64(stmt_lookup_identifier, 2);            const char *scope = reinterpret_cast<const char*>(sqlite3_column_text(stmt_lookup_identifier, 3));            id_type type = (id_type) sqlite3_column_int64(stmt_lookup_identifier, 4);            const char *identifier = reinterpret_cast<const char*>(sqlite3_column_text(stmt_lookup_identifier, 5));            output_identifier(               filename,               line,               column_start,               scope,               type,               sub_type,               identifier);         }      } while (result == SQLITE_ROW);      if (result == SQLITE_DONE)      {         result = SQLITE_OK;      }   }   if (result != SQLITE_OK)   {      const char *errstr = sqlite3_errstr(result);      LOG_FMT(LERR, "index_lookup_identifier: access error (%d: %s)/n", result, errstr != NULL ? errstr : "");      retval = false;   }   (void) sqlite3_finalize(stmt_lookup_identifier);   return retval;}

SSMRESULT CEvaluationEngine::updateModelData(IN int modelId, IN int dataId,        IN ModelPropertyVec *pModelValues){    SSMRESULT res = SSM_E_FAIL;    std::stringstream sstream;    std::string         strSQL;    sqlite3_stmt        *stmt = NULL;    unsigned int        i = 1;    sstream << "update [ModelData" << modelId << "] set lastTime=CURRENT_TIMESTAMP, ";    for (ModelPropertyVec::iterator itor = pModelValues->begin();         itor != pModelValues->end(); ++itor)    {        sstream << itor->propertyName << "=?";        if (itor < pModelValues->end() - 1)        {            sstream << ",";        }    }    sstream << " where dataId = " << dataId << ";" << std::ends;    strSQL = sstream.str();    CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);    for (ModelPropertyVec::iterator itor = pModelValues->begin();         itor != pModelValues->end(); ++itor)    {        switch (itor->propertyType)        {            case ModelProperty::TYPE_NUMERIC:            case ModelProperty::TYPE_INTEGER:                CHK_SQLITE(sqlite3_bind_int(stmt, i, atoi(itor->propertyValue.c_str())), SQLITE_OK);                break;            case ModelProperty::TYPE_REAL:                CHK_SQLITE(sqlite3_bind_double(stmt, i, atof(itor->propertyValue.c_str())), SQLITE_OK);                break;            case ModelProperty::TYPE_TEXT:                CHK_SQLITE(sqlite3_bind_text(stmt, i, itor->propertyValue.c_str(), itor->propertyValue.size(),                                             SQLITE_STATIC), SQLITE_OK);                break;            default:                SSM_CLEANUP_ASSERT(SSM_E_FAIL);        }        i++;    }    CHK_SQLITE(sqlite3_step(stmt), SQLITE_DONE);    CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);    res = SSM_S_OK;CLEANUP:    return res;}

static intshow(lms_t *lms, const char *orig_path){    const char *sql = ("SELECT id, path, size FROM files WHERE path LIKE ? "                       "AND dtime = 0");    char buf[PATH_MAX + 2];    char path[PATH_MAX];    const char *db_path;    sqlite3 *db;    sqlite3_stmt *stmt = NULL;    int r, len;    if (!realpath(orig_path, path)) {        len = strlen(orig_path);        if (len + 1 < PATH_MAX)            memcpy(path, orig_path, len + 1);        else {            fprintf(stderr, "ERROR: path is too long: %s/n", orig_path);            return -1;        }    }    len = strlen(path);    if (len + sizeof("/%") >= PATH_MAX) {        fprintf(stderr, "ERROR: path is too long: /"%s/" + /%%/n", path);        return -1;    }    db_path = lms_get_db_path(lms);    if (sqlite3_open(db_path, &db) != SQLITE_OK) {        fprintf(stderr, "ERROR: could not open DB /"%s/": %s/n",                db_path, sqlite3_errmsg(db));        r = -1;        goto close_and_exit;    }    if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {        fprintf(stderr, "ERROR: could not prepare /"%s/": %s/n", sql,                sqlite3_errmsg(db));        r = -1;        goto close_and_exit;    }    memcpy(buf, path, len);    if (len > 0 && path[len - 1] != '/') {        buf[len] = '/';        len++;    }    buf[len] = '%';    len++;    buf[len] = '/0';    if (sqlite3_bind_text(stmt, 1, buf, len, SQLITE_STATIC) != SQLITE_OK) {        fprintf(stderr, "ERROR: could not bind path query '%s'/n", buf);        r = -1;        goto close_and_exit;    }    printf("BEGIN: all files starting with directory '%s'/n", path);    while ((r = sqlite3_step(stmt)) == SQLITE_ROW) {        uint64_t id;        const char *p;        size_t size;        id = sqlite3_column_int64(stmt, 0);        p = sqlite3_column_blob(stmt, 1);        size = sqlite3_column_int(stmt, 2);        printf("%" PRIu64 " /"%s/" %zd/n", id, p, size);    }    printf("END: all files starting with directory '%s'/n", path);    if (r == SQLITE_DONE)        r = 0;    else if (r == SQLITE_ERROR) {        fprintf(stderr, "ERROR: could not step statement: %s/n",                sqlite3_errmsg(db));        r = -1;    } else {        fprintf(stderr, "ERROR: unknow step return value: %d/n", r);        r = 0;    }close_and_exit:    if (stmt)        sqlite3_finalize(stmt);    sqlite3_close(db);    return r;}

int main(int argc, char *argv[]) {	if (argc != 2) {		showUsage(argv[0]);		return 1;	}	if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {		showUsage(argv[0]);		return 0;	}	if (strcmp(argv[1], "-v") == 0 || strcmp(argv[1], "--version") == 0) {		showCopyright(argv[0]);		return 0;	}	char *temp = (char *)malloc(strlen(argv[1]) + 1 + 1);	sprintf(temp, "%s%%", argv[1]);	char *term = correctSlash(temp);	free(temp);	sqlite3 *db = getDatabase();	if (!db) {		showError("no database-connection");		free(term);		return 1;	}	int rc;	sqlite3_stmt *stmt;	rc = sqlite3_prepare_v2(db, "SELECT name FROM directory WHERE name LIKE ? ORDER BY name ASC;", -1, &stmt, NULL);	if (rc != SQLITE_OK) {		showError(sqlite3_errmsg(db));		sqlite3_finalize(stmt);		sqlite3_close(db);		free(term);		return 1;	}	rc = sqlite3_bind_text(stmt, 1, term, strlen(term), SQLITE_STATIC);	if (rc != SQLITE_OK) {		showError(sqlite3_errmsg(db));		sqlite3_finalize(stmt);		sqlite3_close(db);		free(term);		return 1;	}	size_t count = 0;	const char *dir;	while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {		++count;		dir = (char *)sqlite3_column_text(stmt, 0);		printf("%s/n", dir);		if (dropFile(db, dir)) {			showError(sqlite3_errmsg(db));			sqlite3_finalize(stmt);			sqlite3_close(db);			free(term);			return 1;		}		if (dropDirectory(db, dir)) {			showError(sqlite3_errmsg(db));			sqlite3_finalize(stmt);			sqlite3_close(db);			free(term);			return 1;		}	}	switch (count) {		case 0:			printf("no directory dropped/n");			break;		case 1:			printf("1 directory dropped/n");			break;		default:			printf("%ld directories dropped/n", count);	}	sqlite3_finalize(stmt);	sqlite3_close(db);	return 0;}

SSMRESULT CEvaluationEngine::addModelData(IN int modelId, IN int parentModelId, IN int parentDataId,        IN ModelPropertyVec *pModelValues, OUT int *pDataId){    SSMRESULT           res = SSM_E_FAIL;    std::stringstream   sstream;    std::string         strSQL;    sqlite3_stmt        *stmt = NULL;    int                 lPos = 0;    unsigned int        i;    sstream << "insert into [ModelData" << modelId << "] (";    for (ModelPropertyVec::iterator itor = pModelValues->begin();         itor != pModelValues->end(); ++itor)    {        sstream << itor->propertyName;        if (itor < pModelValues->end() - 1)        {            sstream << ",";        }    }    sstream << ") values (";    for (i = 0; i < pModelValues->size(); i++)    {        sstream << "?";        if (i < pModelValues->size() - 1)        {            sstream << ",";        }    }    sstream << ");" << std::ends;    strSQL = sstream.str();    CHK_SQLITE(sqlite3_prepare_v2(m_pSQLite3, strSQL.c_str(), strSQL.length(), &stmt, NULL), SQLITE_OK);    sstream.str("");    i = 1;    for (ModelPropertyVec::iterator itor = pModelValues->begin();         itor != pModelValues->end(); ++itor)    {        switch (itor->propertyType)        {            case ModelProperty::TYPE_NUMERIC:            case ModelProperty::TYPE_INTEGER:                CHK_SQLITE(sqlite3_bind_int(stmt, i, atoi(itor->propertyValue.c_str())), SQLITE_OK);                break;            case ModelProperty::TYPE_REAL:                CHK_SQLITE(sqlite3_bind_double(stmt, i, atof(itor->propertyValue.c_str())), SQLITE_OK);                break;            case ModelProperty::TYPE_TEXT:                CHK_SQLITE(sqlite3_bind_text(stmt, i, itor->propertyValue.c_str(), itor->propertyValue.size(),                                             SQLITE_STATIC), SQLITE_OK);                break;            default:                SSM_CLEANUP_ASSERT(SSM_E_FAIL);        }        i++;    }    m_mtxDataRelation.lock();    CHK_SQLITE(sqlite3_step(stmt), SQLITE_DONE);    CHK_SQLITE(sqlite3_finalize(stmt), SQLITE_OK);    SSM_CLEANUP_ASSERT(executeSQL_IntReturn("select last_insert_rowid();", pDataId));    sstream << "select lPos from [DataRelation] where modelId = " << parentModelId << " and dataId = "            << parentDataId << ";" << std::ends;    SSM_CLEANUP_ASSERT(executeSQL_IntReturn(sstream.str(), &lPos));    sstream.str("");    sstream << "update [DataRelation] set rPos = rPos + 2 where rPos > " << lPos << ";" << std::ends;    SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));    sstream.str("");    sstream << "update [DataRelation] set lPos = lPos + 2 where lPos > " << lPos << ";" << std::ends;    SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));    sstream.str("");    sstream << "insert into [DataRelation] values (null, " << modelId << ", " << lPos + 1 << ", " <<            lPos + 2 <<            ", " << *pDataId << ");" << std::ends;    SSM_CLEANUP_ASSERT(executeSQL_NoReturn(sstream.str()));CLEANUP:    m_mtxDataRelation.unlock();    return res;}

static void dbd_sqlite3_bbind(apr_dbd_prepared_t * statement,                              const void **values){    sqlite3_stmt *stmt = statement->stmt;    int i, j;    apr_dbd_type_e type;    for (i = 0, j = 0; i < statement->nargs; i++, j++) {        type = (values[j] == NULL ? APR_DBD_TYPE_NULL : statement->types[i]);        switch (type) {        case APR_DBD_TYPE_TINY:            sqlite3_bind_int(stmt, i + 1, *(char*)values[j]);            break;        case APR_DBD_TYPE_UTINY:            sqlite3_bind_int(stmt, i + 1, *(unsigned char*)values[j]);            break;        case APR_DBD_TYPE_SHORT:            sqlite3_bind_int(stmt, i + 1, *(short*)values[j]);            break;        case APR_DBD_TYPE_USHORT:            sqlite3_bind_int(stmt, i + 1, *(unsigned short*)values[j]);            break;        case APR_DBD_TYPE_INT:            sqlite3_bind_int(stmt, i + 1, *(int*)values[j]);            break;        case APR_DBD_TYPE_UINT:            sqlite3_bind_int(stmt, i + 1, *(unsigned int*)values[j]);            break;        case APR_DBD_TYPE_LONG:            sqlite3_bind_int64(stmt, i + 1, *(long*)values[j]);            break;        case APR_DBD_TYPE_ULONG:            sqlite3_bind_int64(stmt, i + 1, *(unsigned long*)values[j]);            break;        case APR_DBD_TYPE_LONGLONG:            sqlite3_bind_int64(stmt, i + 1, *(apr_int64_t*)values[j]);            break;        case APR_DBD_TYPE_ULONGLONG:            sqlite3_bind_int64(stmt, i + 1, *(apr_uint64_t*)values[j]);            break;        case APR_DBD_TYPE_FLOAT:            sqlite3_bind_double(stmt, i + 1, *(float*)values[j]);            break;        case APR_DBD_TYPE_DOUBLE:            sqlite3_bind_double(stmt, i + 1, *(double*)values[j]);            break;        case APR_DBD_TYPE_STRING:        case APR_DBD_TYPE_TEXT:        case APR_DBD_TYPE_TIME:        case APR_DBD_TYPE_DATE:        case APR_DBD_TYPE_DATETIME:        case APR_DBD_TYPE_TIMESTAMP:        case APR_DBD_TYPE_ZTIMESTAMP:            sqlite3_bind_text(stmt, i + 1, values[j], strlen(values[j]),                              SQLITE_STATIC);            break;        case APR_DBD_TYPE_BLOB:        case APR_DBD_TYPE_CLOB:            {            char *data = (char*)values[j];            apr_size_t size = *(apr_size_t*)values[++j];            sqlite3_bind_blob(stmt, i + 1, data, size, SQLITE_STATIC);            /* skip table and column */            j += 2;            }            break;        case APR_DBD_TYPE_NULL:        default:            sqlite3_bind_null(stmt, i + 1);            break;        }    }    return;}

bool SqlitePreparedStatement::bindValue(KDbField *field, const QVariant& value, int par){    if (value.isNull()) {        //no value to bind or the value is null: bind NULL        int res = sqlite3_bind_null(m_sqlResult->prepared_st, par);        if (res != SQLITE_OK) {            m_result.setServerErrorCode(res);            storeResult(&m_result);            return false;        }        return true;    }    if (field->isTextType()) {        //! @todo optimize: make a static copy so SQLITE_STATIC can be used        const QByteArray utf8String(value.toString().toUtf8());        int res = sqlite3_bind_text(m_sqlResult->prepared_st, par,                                    utf8String.constData(), utf8String.length(), SQLITE_TRANSIENT /*??*/);        if (res != SQLITE_OK) {            m_result.setServerErrorCode(res);            storeResult(&m_result);            return false;        }        return true;    }    switch (field->type()) {    case KDbField::Byte:    case KDbField::ShortInteger:    case KDbField::Integer: {        //! @todo what about unsigned > INT_MAX ?        bool ok;        const int intValue = value.toInt(&ok);        if (ok) {            int res = sqlite3_bind_int(m_sqlResult->prepared_st, par, intValue);            if (res != SQLITE_OK) {                m_result.setServerErrorCode(res);                storeResult(&m_result);                return false;            }        } else {            int res = sqlite3_bind_null(m_sqlResult->prepared_st, par);            if (res != SQLITE_OK) {                m_result.setServerErrorCode(res);                storeResult(&m_result);                return false;            }        }        break;    }    case KDbField::Float:    case KDbField::Double: {        int res = sqlite3_bind_double(m_sqlResult->prepared_st, par, value.toDouble());        if (res != SQLITE_OK) {            m_result.setServerErrorCode(res);            storeResult(&m_result);            return false;        }        break;    }    case KDbField::BigInteger: {        //! @todo what about unsigned > LLONG_MAX ?        bool ok;        const qint64 int64Value = value.toLongLong(&ok);        if (ok) {            int res = sqlite3_bind_int64(m_sqlResult->prepared_st, par, int64Value);            if (res != SQLITE_OK) {                m_result.setServerErrorCode(res);                storeResult(&m_result);                return false;            }        } else {            int res = sqlite3_bind_null(m_sqlResult->prepared_st, par);            if (res != SQLITE_OK) {                m_result.setServerErrorCode(res);                storeResult(&m_result);                return false;            }        }        break;    }    case KDbField::Boolean: {        int res = sqlite3_bind_text(m_sqlResult->prepared_st, par, value.toBool() ? "1" : "0",                                    1, SQLITE_TRANSIENT /*??*/);        if (res != SQLITE_OK) {            m_result.setServerErrorCode(res);            storeResult(&m_result);            return false;        }        break;    }    case KDbField::Time: {        int res = sqlite3_bind_text(m_sqlResult->prepared_st, par,                                    qPrintable(value.toTime().toString(Qt::ISODate)),                                    QLatin1String("HH:MM:SS").size(), SQLITE_TRANSIENT /*??*/);        if (res != SQLITE_OK) {            m_result.setServerErrorCode(res);            storeResult(&m_result);            return false;        }        break;//.........这里部分代码省略.........

int __dbfile_sync_config(sqlite3 *db, unsigned int block_size){	int ret;	sqlite3_stmt *stmt = NULL;	ret = sqlite3_prepare_v2(db,				 "INSERT INTO config VALUES (?1, ?2)", -1,				 &stmt, NULL);	if (ret) {		perror_sqlite(ret, "preparing statement");		return ret;	}	ret = sqlite3_bind_text(stmt, 1, "version_major", -1, SQLITE_STATIC);	if (ret)		goto out;	ret = sqlite3_bind_int(stmt, 2, DB_FILE_MAJOR);	if (ret)		goto out;	ret = sqlite3_step(stmt);	if (ret != SQLITE_DONE)		goto out;	sqlite3_reset(stmt);	ret = sqlite3_bind_text(stmt, 1, "version_minor", -1, SQLITE_STATIC);	if (ret)		goto out;	ret = sqlite3_bind_int(stmt, 2, DB_FILE_MINOR);	if (ret)		goto out;	ret = sqlite3_step(stmt);	if (ret != SQLITE_DONE)		goto out;	sqlite3_reset(stmt);	ret = sqlite3_bind_text(stmt, 1, "hash_type", -1, SQLITE_STATIC);	if (ret)		goto out;	ret = sqlite3_bind_text(stmt, 2, hash_type, 8, SQLITE_TRANSIENT);	if (ret)		goto out;	ret = sqlite3_step(stmt);	if (ret != SQLITE_DONE)		goto out;	sqlite3_reset(stmt);	ret = sqlite3_bind_text(stmt, 1, "block_size", -1, SQLITE_STATIC);	if (ret)		goto out;	ret = sqlite3_bind_int(stmt, 2, block_size);	if (ret)		goto out;	ret = sqlite3_step(stmt);	if (ret != SQLITE_DONE)		goto out;	sqlite3_reset(stmt);	ret = 0;out:	sqlite3_finalize(stmt);	if (ret) {		perror_sqlite(ret, "binding");	}	return ret;}

 void Statement::BindCString(int col, const char* val)  {   CheckOk(sqlite3_bind_text(GetStatement(), col + 1, val, -1, SQLITE_TRANSIENT),           ErrorCode_BadParameterType); }

// Bind a text value to a parameter "?", "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statementvoid Statement::bind(const int aIndex, const char* apValue){    int ret = sqlite3_bind_text(mStmtPtr, aIndex, apValue, -1, SQLITE_TRANSIENT);    check(ret);}

void Database::Statement::bind(int parameter, const String &value){	if(!parameter) return;	if(sqlite3_bind_text(mStmt, parameter, value.c_str(), -1, SQLITE_TRANSIENT) != SQLITE_OK)		throw DatabaseException(mDb, String("Unable to bind parameter ") + String::number(parameter));  }

// Bind a string value to a parameter "?NNN", ":VVV", "@VVV" or "$VVV" in the SQL prepared statementvoid Statement::bind(const char* apName, const std::string& aValue){    int index = sqlite3_bind_parameter_index(mStmtPtr, apName);    int ret   = sqlite3_bind_text(mStmtPtr, index, aValue.c_str(), static_cast<int>(aValue.size()), SQLITE_TRANSIENT);    check(ret);}

/* Returns true if the file needs to be analyzed */bool index_prepare_for_file(fp_data& fpd){   int result;   bool retval = true;   sqlite3_int64 filerow = 0;   result = sqlite3_bind_text(cpd.stmt_lookup_file,                              1,                              fpd.filename,                              -1,                              SQLITE_STATIC);   if (result == SQLITE_OK)   {      result = sqlite3_step(cpd.stmt_lookup_file);   }   if (result == SQLITE_ROW)   {      filerow = sqlite3_column_int64(cpd.stmt_lookup_file, 0);      const char *ingest =         (const char *) sqlite3_column_text(cpd.stmt_lookup_file, 1);      if (strcmp(fpd.digest, ingest) == 0)      {         LOG_FMT(LNOTE, "File %s(%s) exists in index at filerow %" PRId64 " with same digest/n", fpd.filename, fpd.digest, (int64_t) filerow);         result = SQLITE_OK;         retval = false;      }      else      {         LOG_FMT(LNOTE, "File %s(%s) exists in index at filerow %" PRId64 " with different digest (%s)/n", fpd.filename, fpd.digest, (int64_t) filerow, ingest);         result = index_replace_file(fpd.digest, fpd.filename);         if (result == SQLITE_OK)         {            result = index_prune_entries(filerow);         }      }   }   else if (result == SQLITE_DONE)   {      result = index_insert_file(fpd.digest, fpd.filename, &filerow);      LOG_FMT(LNOTE, "File %s(%s) does not exist in index, inserted at filerow %" PRId64 "/n", fpd.filename, fpd.digest, (int64_t) filerow);   }   if (result == SQLITE_OK)   {      result = sqlite3_bind_int64(cpd.stmt_insert_reference,                                  1,                                  filerow);   }   if (result == SQLITE_OK)   {      result = sqlite3_bind_int64(cpd.stmt_insert_definition,                                  1,                                  filerow);   }   if (result == SQLITE_OK)   {      result = sqlite3_bind_int64(cpd.stmt_insert_declaration,                                  1,                                  filerow);   }   if (result != SQLITE_OK)   {      const char *errstr = sqlite3_errstr(result);      LOG_FMT(LERR, "index_prepare_for_file: access error (%d: %s)/n", result, errstr != NULL ? errstr : "");      retval = false;   }   (void) sqlite3_reset(cpd.stmt_lookup_file);   return retval;}

static krb5_error_code KRB5_CALLCONVscc_move(krb5_context context, krb5_ccache from, krb5_ccache to){    krb5_scache *sfrom = SCACHE(from);    krb5_scache *sto = SCACHE(to);    krb5_error_code ret;    if (strcmp(sfrom->file, sto->file) != 0) {	krb5_set_error_message(context, KRB5_CC_BADNAME,			       N_("Can't handle cross database "				  "credential move: %s -> %s", ""),			       sfrom->file, sto->file);	return KRB5_CC_BADNAME;    }    ret = make_database(context, sfrom);    if (ret)	return ret;    ret = exec_stmt(context, sfrom->db,		    "BEGIN IMMEDIATE TRANSACTION", KRB5_CC_IO);    if (ret) return ret;    if (sto->cid != SCACHE_INVALID_CID) {	/* drop old cache entry */	sqlite3_bind_int(sfrom->dcache, 1, sto->cid);	do {	    ret = sqlite3_step(sfrom->dcache);	} while (ret == SQLITE_ROW);	sqlite3_reset(sfrom->dcache);	if (ret != SQLITE_DONE) {	    krb5_set_error_message(context, KRB5_CC_IO,				   N_("Failed to delete old cache: %d", ""),				   (int)ret);	    goto rollback;	}    }    sqlite3_bind_text(sfrom->ucachen, 1, sto->name, -1, NULL);    sqlite3_bind_int(sfrom->ucachen, 2, sfrom->cid);    do {	ret = sqlite3_step(sfrom->ucachen);    } while (ret == SQLITE_ROW);    sqlite3_reset(sfrom->ucachen);    if (ret != SQLITE_DONE) {	krb5_set_error_message(context, KRB5_CC_IO,			       N_("Failed to update new cache: %d", ""),			       (int)ret);	goto rollback;    }    sto->cid = sfrom->cid;    ret = exec_stmt(context, sfrom->db, "COMMIT", KRB5_CC_IO);    if (ret) return ret;    scc_free(sfrom);    return 0;rollback:    exec_stmt(context, sfrom->db, "ROLLBACK", 0);    scc_free(sfrom);    return KRB5_CC_IO;}

	/*		Binds a string to a parameter	*/	bool StatementPrivate::bind(unsigned int index, char const * text) const {		return sqlite3_bind_text(stmt_, index, text, -1, SQLITE_TRANSIENT) == SQLITE_OK;	}

int main( int argc, const char* argv[]){    const char* key = "123";  const char* create = "CREATE TABLE t1( id TEXT PRIMARY KEY, a TEXT, b TEXT);";  const char* insert = "INSERT INTO t1 (id,a,b) VALUES (1,'a','b');";  const char* localPath = "./attach-local.db";  const char* remotePath = "./attach-remote.db";  const char* rekeyPath = "./attach-rekey.db";  const char* attach_sql = "ATTACH DATABASE ? AS rekey KEY ?;";  int rc;  sqlite3 *local_db, *remote_db;    char *errorPointer;  sqlite3_stmt *stmt;    // create the remote db with legacy settings  if (sqlite3_open(remotePath, &remote_db) != SQLITE_OK) {    ERROR(("sqlite3_open failed for %s: %s/n", remotePath, sqlite3_errmsg(remote_db)))    exit(1);  }  sqlite3_key(remote_db, key, strlen(key));  sqlite3_exec(remote_db, "PRAGMA kdf_iter = 4000;", NULL, 0, NULL);  sqlite3_exec(remote_db, create, NULL, 0, NULL);  sqlite3_exec(remote_db, insert, NULL, 0, NULL);  // close it to write it out to storage...  sqlite3_close(remote_db);    // create the local db with current settings  if (sqlite3_open(localPath, &local_db) != SQLITE_OK) {    ERROR(("sqlite3_open failed for %s: %s/n", localPath, sqlite3_errmsg(local_db)))    exit(1);  }  sqlite3_key(local_db, key, strlen(key));  sqlite3_exec(local_db, "PRAGMA kdf_iter = 64000;", NULL, 0, NULL);  sqlite3_exec(local_db, create, NULL, 0, NULL);  sqlite3_exec(local_db, insert, NULL, 0, NULL);  // close it to write it out to storage...  sqlite3_close(local_db);    // upgrade the remote db via rekey  if (sqlite3_open(remotePath, &remote_db) != SQLITE_OK) {    ERROR(("sqlite3_open failed for %s: %s/n", remotePath, sqlite3_errmsg(remote_db)))    exit(1);  }  sqlite3_key(remote_db, key, strlen(key));  sqlite3_exec(remote_db, "PRAGMA kdf_iter = 4000;", NULL, 0, NULL);  if (sqlite3_exec(remote_db, "SELECT * FROM sqlite_master;", NULL, 0, &errorPointer) != SQLITE_OK) {    ERROR(("select from sqlite_master failed: %s/n", errorPointer));    sqlite3_free(errorPointer);    exit(1);  }  // prepare stmt for attach  rc = sqlite3_prepare_v2(remote_db, attach_sql, -1, &stmt, NULL);  if (rc != SQLITE_OK) {    ERROR(("sqlite3_prepare_v2 failed for %s: %s/n", attach_sql, sqlite3_errmsg(remote_db)))    exit(1);  }  // "ATTACH DATABASE ? AS rekey KEY ?;";  sqlite3_bind_text(stmt, 1, rekeyPath, -1, SQLITE_TRANSIENT);  sqlite3_bind_text(stmt, 2, key, -1, SQLITE_TRANSIENT);  if (sqlite3_step(stmt) != SQLITE_DONE) {    ERROR(("rekey attach failed: %s/n", sqlite3_errmsg(remote_db)));    sqlite3_free(errorPointer);    sqlite3_finalize(stmt);    exit(1);  }  sqlite3_finalize(stmt);  sqlite3_exec(remote_db, "PRAGMA rekey.kdf_iter = 64000;", NULL, 0, NULL);  rc = sqlite3_exec(remote_db, "SELECT sqlcipher_export('rekey');", NULL, 0, NULL);  if (rc != SQLITE_OK) {    ERROR(("sqlcipher_export failed: %s/n", sqlite3_errmsg(remote_db)))    exit(1);  }  sqlite3_close(remote_db);  // re-open local_db and attach rekeyed database  if (sqlite3_open(localPath, &local_db) != SQLITE_OK) {    ERROR(("sqlite3_open failed for %s: %s/n", localPath, sqlite3_errmsg(local_db)))    exit(1);  }  sqlite3_key(local_db, key, strlen(key));  sqlite3_exec(local_db, "PRAGMA kdf_iter = 64000;", NULL, 0, NULL);  if (sqlite3_exec(local_db, "SELECT * FROM sqlite_master;", NULL, 0, &errorPointer) != SQLITE_OK) {    ERROR(("select from sqlite_master failed: %s/n", errorPointer));    sqlite3_free(errorPointer);    exit(1);  }  // prepare stmt for attach on local_db  // This is the heart of our test: does attaching this rekey'd db succeed or fail?  rc = sqlite3_prepare_v2(local_db, attach_sql, -1, &stmt, NULL);  if (rc != SQLITE_OK) {    ERROR(("sqlite3_prepare_v2 failed for %s: %s/n", attach_sql, sqlite3_errmsg(remote_db)))    exit(1);  }  // "ATTACH DATABASE ? AS rekey KEY ?;";  sqlite3_bind_text(stmt, 1, rekeyPath, -1, SQLITE_TRANSIENT);  sqlite3_bind_text(stmt, 2, key, -1, SQLITE_TRANSIENT);  if (sqlite3_step(stmt) != SQLITE_DONE) {    ERROR(("rekey attach to local failed: %s/n", sqlite3_errmsg(local_db)));    sqlite3_free(errorPointer);    sqlite3_finalize(stmt);    exit(1);//.........这里部分代码省略.........

//.........这里部分代码省略.........  }  if( iMode==MODE_UPDATE ){    rc = sqlite3_prepare_v2(db,          "INSERT OR IGNORE INTO wordcount(word,cnt) VALUES(?1,0)",          -1, &pInsert, 0);    if( rc ) fatal_error("Could not prepare the INSERT statement: %s/n",                         sqlite3_errmsg(db));  }  if( iMode==MODE_REPLACE ){    rc = sqlite3_prepare_v2(db,          "REPLACE INTO wordcount(word,cnt)"          "VALUES(?1,coalesce((SELECT cnt FROM wordcount WHERE word=?1),0)+1)",          -1, &pInsert, 0);    if( rc ) fatal_error("Could not prepare the REPLACE statement: %s/n",                          sqlite3_errmsg(db));  }  if( iMode==MODE_DELETE ){    rc = sqlite3_prepare_v2(db,          "DELETE FROM wordcount WHERE word=?1",          -1, &pDelete, 0);    if( rc ) fatal_error("Could not prepare the DELETE statement: %s/n",                         sqlite3_errmsg(db));  }  /* Process the input file */  while( fgets(zInput, sizeof(zInput), in) ){    for(i=0; zInput[i]; i++){      if( !isalpha(zInput[i]) ) continue;      for(j=i+1; isalpha(zInput[j]); j++){}      /* Found a new word at zInput[i] that is j-i bytes long.       ** Process it into the wordcount table.  */      if( iMode==MODE_DELETE ){        sqlite3_bind_text(pDelete, 1, zInput+i, j-i, SQLITE_STATIC);        if( sqlite3_step(pDelete)!=SQLITE_DONE ){          fatal_error("DELETE failed: %s/n", sqlite3_errmsg(db));        }        sqlite3_reset(pDelete);      }else if( iMode==MODE_SELECT ){        sqlite3_bind_text(pSelect, 1, zInput+i, j-i, SQLITE_STATIC);        rc = sqlite3_step(pSelect);        sqlite3_reset(pSelect);        if( rc==SQLITE_ROW ){          sqlite3_bind_text(pUpdate, 1, zInput+i, j-i, SQLITE_STATIC);          if( sqlite3_step(pUpdate)!=SQLITE_DONE ){            fatal_error("UPDATE failed: %s/n", sqlite3_errmsg(db));          }          sqlite3_reset(pUpdate);        }else if( rc==SQLITE_DONE ){          sqlite3_bind_text(pInsert, 1, zInput+i, j-i, SQLITE_STATIC);          if( sqlite3_step(pInsert)!=SQLITE_DONE ){            fatal_error("Insert failed: %s/n", sqlite3_errmsg(db));          }          sqlite3_reset(pInsert);        }else{          fatal_error("SELECT failed: %s/n", sqlite3_errmsg(db));        }      }else if( iMode==MODE_QUERY ){        sqlite3_bind_text(pSelect, 1, zInput+i, j-i, SQLITE_STATIC);        if( sqlite3_step(pSelect)==SQLITE_ROW ){          sumCnt += sqlite3_column_int64(pSelect, 0);        }        sqlite3_reset(pSelect);      }else{        sqlite3_bind_text(pInsert, 1, zInput+i, j-i, SQLITE_STATIC);        if( sqlite3_step(pInsert)!=SQLITE_DONE ){

int bind_execution_sql(sqlite3_stmt * stmt, std::string unique_id, int start_time, int end_time) {    sqlite3_bind_text(stmt, 1, unique_id.c_str(), -1, SQLITE_TRANSIENT);    sqlite3_bind_int(stmt, 2, start_time);    sqlite3_bind_int(stmt, 3, end_time);    return step_stmt(stmt);}

//.........这里部分代码省略.........    sqlite3_exec(sql_db, "PRAGMA synchronous=0;", NULL, NULL, NULL);    //sqlite3_exec(sql_db, "PRAGMA cache_size=200;", NULL, NULL, NULL);    block_db->cursor(block_db, NULL, &cur, 0);    printf("Starting writes!/n");    while ((ch = getopt(argc, argv, "b:n:x:")) != EOF)		switch (ch) {		case 'b':            key.data = optarg;            key.size = strlen(optarg)+1;            printf("%s, %u/n", key.data, key.size);            custom_block = 1;            if(DB_NOTFOUND == cur->pget(cur, &key, &pkey, &data, DB_SET)){                printf("Block not found/n");                return(EXIT_FAILURE);            }			break;        case 'n':            start_rec = (u_int32_t)atol(optarg);            break;        case 'x':            end_block = (u_int32_t)atol(optarg);            has_max = 1;            break;        }    argc -= optind;	argv += optind;    if (*argv != NULL)		return (EXIT_FAILURE);    sql_ret = sqlite3_prepare_v2(sql_db, sql_query, -1, &ppStmt, NULL);    while(DB_NOTFOUND != cur->pget(cur, &key, &pkey, &data,                (custom_block? DB_SET : DB_NEXT_NODUP))){        if(has_max && numblocks++ >= end_block) break;        do{            if(!(++numrecs % 10000)){                primary->sync(primary, 0);                block_db->sync(primary, 0);                dbenv->memp_sync(dbenv, NULL);                cur->dup(cur, &tmp_cur, DB_POSITION);                tmp_cur->pget(tmp_cur, &key, &pkey, &data, DB_CURRENT);                cur->close(cur);                cur = tmp_cur;                sqlite3_finalize(ppStmt);                sqlite3_close(sql_db);                sqlite3_open(sql_file, &sql_db);                sqlite3_exec(sql_db, "PRAGMA synchronous=0;", NULL, NULL, NULL);                sql_ret = sqlite3_prepare_v2(sql_db, sql_query, -1, &ppStmt, NULL);                printf("/t %lu records processed.../n", (ulong)numrecs);                //printf("/t Using %lld bytes of memory.../n", sqlite3_memory_used());            }            cur->count(cur, &dup_count, 0);            if(numrecs < start_rec) continue;            if(custom_block || (strncmp(((DbRecord*)data.data)->Invnum_N, "", 1) &&               strcmp(((DbRecord*)data.data)->Invnum_N, ((DbRecord*)data.data)->Invnum))){                                //printf("Invnum_N = %s/n", ((DbRecord *)data.data)->Invnum_N);                //printf("Patent = %s/n", ((DbRecord*)data.data)->Patent);                //printf("InvSeq = %lu/n", (u_long)((DbRecord*)data.data)->InvSeq);                                sql_ret = sqlite3_prepare_v2(sql_db, sql_query, -1, &ppStmt, NULL);                //sql_ret = sqlite3_prepare_v2(sql_db, sql_query2, -1, &ppStmt, NULL);                /*if(numrecs > 920000){                    if(has_tag((DbRecord*)data.data)==NULL)                        printf("HUZZAH!/n");                    printf("Invnum_N: %s/n", has_tag((DbRecord *)data.data));                    printf("%d/n", sql_ret);                }*/                if((sql_ret = sqlite3_bind_text(ppStmt, 1, ((DbRecord *)data.data)->Invnum_N,  -1, SQLITE_STATIC))!=0)//strlen(((DbRecord *)data.data)->Invnum_N)+1                    printf("Bind complaint: %d/n", sql_ret);                index_callback(NULL, NULL, &data, &uid);                if((sql_ret = sqlite3_bind_text(ppStmt, 2, (char*)uid.data, -1, SQLITE_STATIC))!=0)                    printf("Bind complaint: %d/n", sql_ret);                //if((sql_ret=sqlite3_bind_int(ppStmt, 3, (int)((DbRecord *)data.data)->InvSeq))!=0)                //    printf("Bind complaint: %d/n", sql_ret);                //if((sql_ret = sqlite3_step(ppStmt))!=SQLITE_ROW)                //    printf("No results! %d/n", sql_ret);                if((sql_ret = sqlite3_step(ppStmt))!=SQLITE_DONE)                    printf("Step complaint: %d/n", sql_ret);                sqlite3_clear_bindings(ppStmt);                sqlite3_reset(ppStmt);                    }         } while(DB_NOTFOUND !=            cur->pget(cur, &key, &pkey, &data, DB_NEXT_DUP));        if(custom_block) break;    }    sqlite3_finalize(ppStmt);    cur->close(cur);    block_db->close(block_db, 0);    primary->close(primary, 0);    sqlite3_close(sql_db);    return(0);}

//.........这里部分代码省略.........        // If this function is ever called with a different table the finalizer will be called        // and sqlite3_get_auxdata() will return null above, forcing a recompile for the new table.        sqlite3_set_auxdata(context, 0, statement, tokenize_auxdata_delete);    } else {        // Reset the cached statement so that binding the row ID will work properly        sqlite3_reset(statement);    }    // Bind the row ID of the source row    int64_t rowID = sqlite3_value_int64(argv[1]);    err = sqlite3_bind_int64(statement, 2, rowID);    if (err != SQLITE_OK) {        ALOGE("bind failed");        sqlite3_result_null(context);        return;    }    // Bind <data_tag> to the tag column    if (useDataTag) {        int dataTagParamIndex = useTokenIndex ? 4 : 3;        err = sqlite3_bind_value(statement, dataTagParamIndex, argv[5]);        if (err != SQLITE_OK) {            ALOGE("bind failed");            sqlite3_result_null(context);            return;        }    }    // Get the raw bytes for the string to tokenize    // the string will be modified by following code    // however, sqlite did not reuse the string, so it is safe to not dup it    UChar * origData = (UChar *)sqlite3_value_text16(argv[2]);    if (origData == NULL) {        sqlite3_result_null(context);        return;    }    // Get the raw bytes for the delimiter    const UChar * delim = (const UChar *)sqlite3_value_text16(argv[3]);    if (delim == NULL) {        ALOGE("can't get delimiter");        sqlite3_result_null(context);        return;    }    UChar * token = NULL;    UChar *state;    int numTokens = 0;    do {        if (numTokens == 0) {            token = origData;        }        // Reset the program so we can use it to perform the insert        sqlite3_reset(statement);        UErrorCode status = U_ZERO_ERROR;        char keybuf[1024];        uint32_t result = ucol_getSortKey(collator, token, -1, (uint8_t*)keybuf, sizeof(keybuf)-1);        if (result > sizeof(keybuf)) {            // TODO allocate memory for this super big string            ALOGE("ucol_getSortKey needs bigger buffer %d", result);            break;        }        uint32_t keysize = result-1;        uint32_t base16Size = keysize*2;        char *base16buf = (char*)malloc(base16Size);        base16Encode(base16buf, keybuf, keysize);        err = sqlite3_bind_text(statement, 1, base16buf, base16Size, SQLITE_STATIC);        if (err != SQLITE_OK) {            ALOGE(" sqlite3_bind_text16 error %d", err);            free(base16buf);            break;        }        if (useTokenIndex) {            err = sqlite3_bind_int(statement, 3, numTokens);            if (err != SQLITE_OK) {                ALOGE(" sqlite3_bind_int error %d", err);                free(base16buf);                break;            }        }        err = sqlite3_step(statement);        free(base16buf);        if (err != SQLITE_DONE) {            ALOGE(" sqlite3_step error %d", err);            break;        }        numTokens++;        if (numTokens == 1) {            // first call            u_strtok_r(origData, delim, &state);        }    } while ((token = u_strtok_r(NULL, delim, &state)) != NULL);    sqlite3_result_int(context, numTokens);}

bool DbNote::insertTable(Note & note){    sqlite3_stmt *statement;    string stmnt =        "insert into NoteTable (date,NoteText,NoteTitle,NoteRef,KatKey) values (?,?,?,?,?)";    if (!openDB())    {        throw SQLError("Can't open the DB-Connection");        return false;    }    int req = sqlite3_prepare_v2(db, stmnt.c_str(), stmnt.length(), &statement,                                 0);    if (req != SQLITE_OK)    {        throw SQLError("Preparing Insert-Statement failed");        return false;    }    req = sqlite3_bind_text(statement, 1,                            (note.getDate().getDateString()).c_str(),                            (note.getDate().getDateString()).length(), SQLITE_TRANSIENT);    if (req != SQLITE_OK)    {        throw SQLError("Binding Date into insert statement failed");        return false;    }    req = sqlite3_bind_text(statement, 2, (note.getNoteText()).c_str(),                            (note.getNoteText()).length(), SQLITE_TRANSIENT);    if (req != SQLITE_OK)    {        throw SQLError("Binding note text into insert statement failed");        return false;    }    req = sqlite3_bind_text(statement, 3, (note.getNotetitle()).c_str(),                            (note.getNotetitle()).length(), SQLITE_TRANSIENT);    if (req != SQLITE_OK)    {        throw SQLError("Binding note title into insert statement failed");        return false;    }    req = sqlite3_bind_int(statement, 4, note.getNoteRef());    if (req != SQLITE_OK)    {        throw SQLError("Binding note ref into insert statement failed");        return false;    }    req = sqlite3_bind_int(statement, 5, note.getKatKey());    if (req != SQLITE_OK)    {        throw SQLError(            "Binding note category key into insert statement failed");        return false;    }    req = sqlite3_step(statement);    if (req != SQLITE_DONE)    {        throw SQLError("execute of insert statement failed");        return false;    }    sqlite3_finalize(statement);    sqlite3_close(db);    return true;}

void standard_use_type::do_use(){  int result=SQLITE_OK;  convert_to_base();  switch (m_type)  {  case x_null:    result = sqlite3_bind_null (m_st->m_stmt, m_iParam);    break;  case x_bool:    result = sqlite3_bind_int (m_st->m_stmt, m_iParam, as <bool> (m_data)?1:0 );    break;  case x_char:    result = sqlite3_bind_int (m_st->m_stmt, m_iParam, as <char> (m_data));    break;  case x_short:    result = sqlite3_bind_int (m_st->m_stmt, m_iParam, as <short> (m_data));    break;  case x_int:    result = sqlite3_bind_int (m_st->m_stmt, m_iParam, as <int> (m_data));    break;  case x_long:    result = sqlite3_bind_int (m_st->m_stmt, m_iParam, as <long> (m_data));    break;  case x_int64:    result = sqlite3_bind_int64 (m_st->m_stmt, m_iParam, as <int64> (m_data));    break;  case x_uchar:    result = sqlite3_bind_int (m_st->m_stmt, m_iParam, as <unsigned char> (m_data));    break;  case x_ushort:    result = sqlite3_bind_int (m_st->m_stmt, m_iParam, as <unsigned short> (m_data));    break;  case x_uint:    result = sqlite3_bind_int64 (m_st->m_stmt, m_iParam, as <unsigned int> (m_data));    break;  case x_ulong:    result = sqlite3_bind_int64 (m_st->m_stmt, m_iParam, as <unsigned long> (m_data));    break;  case x_uint64:    result = sqlite3_bind_int64 (m_st->m_stmt, m_iParam, as <sqlite3_uint64, sqlite3_int64> (m_data));    break;  case x_float:    result = sqlite3_bind_double (m_st->m_stmt, m_iParam, as <float> (m_data));    break;  case x_double:    result = sqlite3_bind_double (m_st->m_stmt, m_iParam, as <double> (m_data));    break;  case x_cstring:    result = sqlite3_bind_text (m_st->m_stmt, m_iParam, as <char*> (m_data), -1, SQLITE_STATIC);    break;  case x_cwstring:    result = sqlite3_bind_text16 (m_st->m_stmt, m_iParam, as <wchar_t*> (m_data), -1, SQLITE_STATIC);    break;  case x_stdstring:    {      std::string const& s = as <std::string> (m_data);      result = sqlite3_bind_text (m_st->m_stmt,                                  m_iParam,                                  s.c_str(),                                  s.size() * sizeof(s[0]),                                   SQLITE_STATIC);    }    break;  case x_stdwstring:    {      std::wstring const& s = as <std::wstring> (m_data);      result = sqlite3_bind_text16 (m_st->m_stmt,                                    m_iParam,                                    s.c_str(),                                    s.size() * sizeof(s[0]),                                    SQLITE_STATIC);    }    break;  case x_juceString:    {      String const& s = as <String> (m_data);      result = sqlite3_bind_text (m_st->m_stmt,                                  m_iParam,                                  s.toUTF8(),//.........这里部分代码省略.........