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

SWITCH_DECLARE(int) switch_core_db_bind_int(switch_core_db_stmt_t *pStmt, int i, int iValue){	return sqlite3_bind_int(pStmt, i, iValue);}

intCSQLiteDE::AddBin(int ExprID,				int TransID,				int ExpresID,				int NthBin,				int CtrlCounts,				int ExprCounts){int sqlite_error;tsDEStmSQL *pStm;int BinID;char szQueryBinID[200];pStm = &m_StmSQL[3];								// access sequence statementsif(m_pDB == NULL)	return(eBSFerrInternal);if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 1, ExprID))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 2, TransID))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 3, ExpresID))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 4, NthBin))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 5, CtrlCounts))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 6, CtrlCounts))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_step(pStm->pPrepInsert))!=SQLITE_DONE)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - step prepared statement: %s", sqlite3_errmsg(m_pDB));   	CloseDatabase(true);	return(eBSFerrInternal);	}sqlite3_reset(pStm->pPrepInsert);if(m_bSafe)	{	BinID = -1;	sprintf(szQueryBinID,"select BinID from TblBins where ExprID = %d AND TransID = %d AND ExpresID = %d AND NthBin = %d",ExprID,TransID,ExpresID,NthBin);	sqlite3_exec(m_pDB,szQueryBinID,ExecCallbackID,&BinID,NULL);	}else	BinID = (int)sqlite3_last_insert_rowid(m_pDB);	return(BinID);}

static intgf_sql_update_link_flags (gf_sql_connection_t  *sql_conn,                   char                 *gfid,                   char                 *pargfid,                   char                 *basename,                   int                  update_flag,                   gf_boolean_t         is_update_or_delete){        int ret = -1;        sqlite3_stmt *update_stmt = NULL;        char *update_column = NULL;        char update_str[1024] = "";        CHECK_SQL_CONN (sql_conn, out);        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, pargfid, out);        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, basename, out);        update_column = (is_update_or_delete) ? "LINK_UPDATE" : "W_DEL_FLAG";        sprintf (update_str, "UPDATE "                            GF_FILE_LINK_TABLE                            " SET %s = ?"                            " WHERE GF_ID = ? AND GF_PID = ? AND FNAME = ?;",                            update_column);        /*Prepare statement*/        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, update_str, -1,                                &update_stmt, 0);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_PREPARE_FAILED, "Failed preparing update "                        "statment %s : %s", update_str,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Bind link_update*/        ret = sqlite3_bind_int (update_stmt, 1, update_flag);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_BINDING_FAILED, "Failed binding update_flag %d "                        ": %s", update_flag,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Bind gfid*/        ret = sqlite3_bind_text (update_stmt, 2, gfid, -1, NULL);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Bind pargfid*/        ret = sqlite3_bind_text (update_stmt, 3, pargfid, -1, NULL);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_BINDING_FAILED, "Failed binding parent gfid %s "                        ": %s", pargfid,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Bind basename*/        ret = sqlite3_bind_text (update_stmt, 4, basename, -1, NULL);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_BINDING_FAILED, "Failed binding basename %s : "                        "%s", basename,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Execute the prepare statement*/        if (sqlite3_step(update_stmt) != SQLITE_DONE) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,                        "Failed executing the prepared stmt %s : %s",                        update_str,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        ret = 0;out:        /*Free prepared statement*/        sqlite3_finalize (update_stmt);        return ret;}

bool QSpatiaLiteResult::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("QSpatiaLiteResult",                     "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("QSpatiaLiteResult",                             "Unable to bind parameters"), QSqlError::StatementError, res));                d->finalize();                return false;            }        }    } else {        setLastError(QSqlError(QCoreApplication::translate("QSpatiaLiteResult",                        "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;}

booldb_configuration_set_defaults (const char* location){  sqlite3* db;  sqlite3_stmt* result;  int status;  status = sqlite3_open (location, &db);  if (status != SQLITE_OK) return false;  /* Minimize disk I/O because that can be pretty expensive. */  sqlite3_exec (db, "PRAGMA synchronous = OFF", 0, 0, 0);  sqlite3_exec (db, "PRAGMA journal_mode = MEMORY", 0, 0, 0);  sqlite3_exec (db, "BEGIN TRANSACTION", 0, 0, 0);  /* Empty the table (TRUNCATE is not available in SQLite3). */  status = sqlite3_exec (db, "DELETE FROM config", 0, 0, 0);  /* By using a prepared statement we avoid SQL injection and double memory   * allocation of the query string. */  if (status == SQLITE_OK)    status = sqlite3_prepare_v2 (db,       "INSERT INTO config (key, value) VALUES (?, ?)", -1, &result, NULL);  /* Bind the values to the parameters. Apparantly the first index is 1. */  sqlite3_bind_int (result, 1, KEY_STORAGE_PATH);  /* Try to set '$HOME/Moefel/' as the default storage path.    * When $HOME is not available, fall back to the current directory. */  char* storage_path = NULL;  #ifndef WIN32  char* home = getenv ("HOME");  #else  char* home = NULL;  TCHAR szPath[MAX_PATH];  SHGetFolderPath (NULL, CSIDL_PERSONAL|CSIDL_FLAG_CREATE, NULL, 0, szPath);  home = (char *)&szPath;  #endif  if (home != NULL)    {      storage_path = calloc (1, strlen (home) + 9);      strcpy (storage_path, home);      #ifndef WIN32      strcat (storage_path, "/Moefel/");      #else      strcat (storage_path, "//Moefel//");      #endif      sqlite3_bind_text (result, 2, storage_path, -1, NULL);    }  else    sqlite3_bind_text (result, 2, ".", -1, NULL);  /* Execute the query. */  status = sqlite3_step (result);  /* Commit the changes to the database. */  if (status == SQLITE_DONE)    status = sqlite3_finalize (result),    free (storage_path);  /* Write changes to the database. */  if (status == SQLITE_OK) sqlite3_exec (db, "END TRANSACTION", 0, 0, 0);  sqlite3_close(db);  if (status != SQLITE_OK) return false;  return true;}

	void sqlite3_command::bind(int index, int data) {		if(sqlite3_bind_int(this->stmt, index, data)!=SQLITE_OK)			throw database_error(this->con);	}

//.........这里部分代码省略.........        for(size_t i = 0; i < APDIndex.MaxIndex(); i++) {          // Handle one APD for that row.          double weight = gain.GetValAt(i);          double apd_magnitude = sqlite3_column_double(prep_stmt_pos, 1 + i);          WeightedSumMagnitudes[i] += weight*apd_magnitude;          SumSquareWeights[i] += weight*weight;        }      }      if(ret != SQLITE_DONE) {        std::cerr << "Query returned failure." << std::endl;        exit(1);      }      ret = sqlite3_reset(prep_stmt_pos);      if(ret != SQLITE_OK) {        std::cerr << "Failed to reset a statement." << std::endl;        exit(1);      }      // Update the lightmap values for this bin, overwriting the old ones.      for(size_t i = 0; i < APDIndex.MaxIndex(); i++) {        if(WeightedSumMagnitudes[i] <= 0) posFunc.GetValAt(posBin, i) = 0;        else posFunc.GetValAt(posBin, i) = WeightedSumMagnitudes[i]/SumSquareWeights[i];      }    }    std::cout << "Done computing the position function." << std::endl;    std::cout << "Computing the gain function, holding the position function fixed." << std::endl;    for(size_t gainBin = 0; gainBin < gainFunc.NumSnapshots(); gainBin++) {      LightMap::GainSnapshot& gain = gainFunc.GainAtIndex(gainBin);      // Bind the run range parameters to the query.      bool success = (        sqlite3_bind_int(prep_stmt_run, 1, gain.FirstRun()) == SQLITE_OK and        sqlite3_bind_int(prep_stmt_pos, 2, gain.LastRun()) == SQLITE_OK);      if(not success) {        std::cerr << "Failed to bind values to a select statement." << std::endl;        exit(1);      }      // Retrieve all events which fall in this bin.      // For each APD, we wish to compute the weighted sum of magnitudes      // and the sum of square weights.      LightMap::FuncVsAPD WeightedSumMagnitudes;      LightMap::FuncVsAPD SumSquareWeights;      for(size_t i = 0; i < APDIndex.MaxIndex(); i++) {        WeightedSumMagnitudes[i] = 0;        SumSquareWeights[i] = 0;      }      while((ret = sqlite3_step(prep_stmt_run)) == SQLITE_ROW) {        // Handle a row.        double xpos = sqlite3_column_double(prep_stmt_run, 0);        double ypos = sqlite3_column_double(prep_stmt_run, 1);        double zpos = sqlite3_column_double(prep_stmt_run, 2);        size_t posBin = posFunc.PosIndex().IndexForKey(std::make_pair(std::make_pair(xpos, ypos), zpos));        if(posBin >= posFunc.PosIndex().MaxIndex()) continue; // Kills events out of boundary for lightmap.        const LightMap::FuncVsAPD& posFuncAtBin = posFunc.GetAllValsAt(posBin);        for(size_t i = 0; i < APDIndex.MaxIndex(); i++) {          // Handle one APD for that row.          double weight = posFuncAtBin[i];          double apd_magnitude = sqlite3_column_double(prep_stmt_run, 3 + i);          WeightedSumMagnitudes[i] += weight*apd_magnitude;          SumSquareWeights[i] += weight*weight;        }

int SQLite::BindInt(sqlite3_stmt *pStmt, int pos, int value) {  BOOST_LOG_TRIVIAL(debug) << "database::SQLite::BindInt: Function call";  return sqlite3_bind_int(pStmt, pos, value);}

void SQLiteStatement::bindInt(int index, int32_t value){    sqlite3_bind_int(handle_, index, value);}

static int_bind_arg(lua_State *T, int t_idx, sqlite3_stmt *stmt, int s_idx){	int ret = 0;	int kind = lua_type(T, t_idx);kind_is_known:	switch (kind) {	case LUA_TNIL:		/* Should nil mean NULL..		ret = sqlite3_bind_null(stmt, i-1);		break;		..or don't bind.. */		return SQLITE_OK;	case LUA_TNUMBER:		ret = sqlite3_bind_double(stmt, s_idx,				lua_tonumber(T, t_idx));		break;	case LUA_TSTRING:		{			size_t len;			const char *str = lua_tolstring(T, t_idx, &len);			ret = sqlite3_bind_text(stmt, s_idx,					str, len, SQLITE_STATIC);		}		break;	case BIND_INT:		ret = sqlite3_bind_int(stmt, s_idx,				lua_tointeger(T, t_idx));		break;	case BIND_INT64:		ret = sqlite3_bind_int(stmt, s_idx,				lua_tointeger(T, t_idx));		break;	case BIND_BLOB:		{			size_t len;			const char *str = lua_tolstring(T, t_idx, &len);			ret = sqlite3_bind_blob(stmt, s_idx,					str, len, SQLITE_STATIC);		}		break;	case BIND_BLOB64:		{			size_t len;			const char *str = lua_tolstring(T, t_idx, &len);			ret = sqlite3_bind_blob64(stmt, s_idx,					str, len, SQLITE_STATIC);		}		break;	case BIND_ZEROBLOB:			ret = sqlite3_bind_zeroblob(stmt, s_idx,					lua_tointeger(T, t_idx));		break;	case BIND_ZEROBLOB64:			ret = sqlite3_bind_zeroblob64(stmt, s_idx,					lua_tointeger(T, t_idx));		break;	case LUA_TTABLE:		{			lua_rawgeti(T, t_idx, 1);			kind = lua_tointeger(T, -1);			lua_pop(T, 1);			lua_rawgeti(T, t_idx, 2);			t_idx = -1;			goto kind_is_known;		}	default:		(void)sqlite3_clear_bindings(stmt);		return luaL_argerror(T, t_idx, "expected nil, number or string");	}	if (t_idx == -1) {		lua_pop(T, 1);	}	return ret;}

//.........这里部分代码省略.........  sqlite3_exec(db->handle, "ALTER TABLE presets ADD COLUMN multi_priority INTEGER", NULL, NULL, NULL);  sqlite3_exec(db->handle, "ALTER TABLE presets ADD COLUMN multi_name VARCHAR(256)", NULL, NULL, NULL);  // the unique index only works if the db doesn't have any (name, operation, op_version) more than once. apparently there are dbs out there which do have that. :(  sqlite3_prepare_v2(db->handle, "SELECT p.rowid, p.name, p.operation, p.op_version FROM presets p INNER JOIN "                                 "(SELECT * FROM (SELECT rowid, name, operation, op_version, COUNT(*) AS count "                                 "FROM presets GROUP BY name, operation, op_version) WHERE count > 1) s "                                 "ON p.name = s.name AND p.operation = s.operation AND p.op_version = s.op_version", -1, &stmt, NULL);  char *last_name = NULL, *last_operation = NULL;  int last_op_version = 0;  int i = 0;  while(sqlite3_step(stmt) == SQLITE_ROW)  {    int rowid = sqlite3_column_int(stmt, 0);    const char* name = (const char*)sqlite3_column_text(stmt, 1);    const char* operation = (const char*)sqlite3_column_text(stmt, 2);    int op_version = sqlite3_column_int(stmt, 3);    // is it still the same (name, operation, op_version) triple?    if(!last_name || strcmp(last_name, name) || !last_operation || strcmp(last_operation, operation) || last_op_version != op_version)    {      g_free(last_name);      g_free(last_operation);      last_name = g_strdup(name);      last_operation = g_strdup(operation);      last_op_version = op_version;      i = 0;    }    // find the next free ammended version of name    sqlite3_prepare_v2(db->handle, "SELECT name FROM presets  WHERE name = ?1 || ' (' || ?2 || ')' AND operation = ?3 AND op_version = ?4", -1, &innerstmt, NULL);    while(1)    {      sqlite3_bind_text(innerstmt, 1, name, -1, SQLITE_TRANSIENT);      sqlite3_bind_int(innerstmt, 2, i);      sqlite3_bind_text(innerstmt, 3, operation, -1, SQLITE_TRANSIENT);      sqlite3_bind_int(innerstmt, 4, op_version);      if(sqlite3_step(innerstmt) != SQLITE_ROW)        break;      sqlite3_reset(innerstmt);      sqlite3_clear_bindings(innerstmt);      i++;    }    sqlite3_finalize(innerstmt);    // rename preset    const char *query = "UPDATE presets SET name = name || ' (' || ?1 || ')' WHERE rowid = ?2";    sqlite3_prepare_v2(db->handle, query, -1, &innerstmt, NULL);    sqlite3_bind_int(innerstmt, 1, i);    sqlite3_bind_int(innerstmt, 2, rowid);    if(sqlite3_step(innerstmt) != SQLITE_DONE)    {      all_ok = FALSE;      failing_query = query;      goto end;    }    sqlite3_finalize(innerstmt);  }  sqlite3_finalize(stmt);  g_free(last_name);  g_free(last_operation);  // now we should be able to create the index  _SQLITE3_EXEC(db->handle, "CREATE UNIQUE INDEX IF NOT EXISTS presets_idx ON presets (name, operation, op_version)", NULL, NULL, NULL);  _SQLITE3_EXEC(db->handle, "UPDATE presets SET blendop_version = 1 WHERE blendop_version IS NULL", NULL, NULL, NULL);  _SQLITE3_EXEC(db->handle, "UPDATE presets SET multi_priority = 0 WHERE multi_priority IS NULL", NULL, NULL, NULL);  _SQLITE3_EXEC(db->handle, "UPDATE presets SET multi_name = ' ' WHERE multi_name IS NULL", NULL, NULL, NULL);

bool PDOSqliteStatement::paramHook(PDOBoundParam* param,                                   PDOParamEvent event_type) {  switch (event_type) {  case PDO_PARAM_EVT_EXEC_PRE:    if (executed && !m_done) {      sqlite3_reset(m_stmt);      m_done = 1;    }    if (param->is_param) {      if (param->paramno == -1) {        param->paramno = sqlite3_bind_parameter_index(m_stmt,                                                      param->name.c_str()) - 1;      }      switch (PDO_PARAM_TYPE(param->param_type)) {      case PDO_PARAM_STMT:        return false;      case PDO_PARAM_NULL:        if (sqlite3_bind_null(m_stmt, param->paramno + 1) == SQLITE_OK) {          return true;        }        handleError(__FILE__, __LINE__);        return false;      case PDO_PARAM_INT:      case PDO_PARAM_BOOL:        if (param->parameter.isNull()) {          if (sqlite3_bind_null(m_stmt, param->paramno + 1) == SQLITE_OK) {            return true;          }        } else {          if (SQLITE_OK == sqlite3_bind_int(m_stmt, param->paramno + 1,                                            param->parameter.toInt64())) {            return true;          }        }        handleError(__FILE__, __LINE__);        return false;      case PDO_PARAM_LOB:        if (param->parameter.isResource()) {          Variant buf = HHVM_FN(stream_get_contents)(                        param->parameter.toResource());          if (!same(buf, false)) {            param->parameter = buf;          } else {            pdo_raise_impl_error(dbh, this, "HY105",                                 "Expected a stream resource");            return false;          }        } else if (param->parameter.isNull()) {          if (sqlite3_bind_null(m_stmt, param->paramno + 1) == SQLITE_OK) {            return true;          }          handleError(__FILE__, __LINE__);          return false;        }        {          String sparam = param->parameter.toString();          if (SQLITE_OK == sqlite3_bind_blob(m_stmt, param->paramno + 1,                                             sparam.data(), sparam.size(),                                             SQLITE_STATIC)) {            return true;          }        }        handleError(__FILE__, __LINE__);        return false;      case PDO_PARAM_STR:      default:        if (param->parameter.isNull()) {          if (sqlite3_bind_null(m_stmt, param->paramno + 1) == SQLITE_OK) {            return true;          }        } else {          String sparam = param->parameter.toString();          if (SQLITE_OK == sqlite3_bind_text(m_stmt, param->paramno + 1,                                             sparam.data(), sparam.size(),                                             SQLITE_STATIC)) {            return true;          }        }        handleError(__FILE__, __LINE__);        return false;      }    }    break;  default:;  }  return true;}

void Query::bindInt(int col, int val){    sqlite3_bind_int(m_Stmt, col, val);}

static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param,		enum pdo_param_event event_type){	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;	zval *parameter;	switch (event_type) {		case PDO_PARAM_EVT_EXEC_PRE:			if (stmt->executed && !S->done) {				sqlite3_reset(S->stmt);				S->done = 1;			}			if (param->is_param) {				if (param->paramno == -1) {					param->paramno = sqlite3_bind_parameter_index(S->stmt, ZSTR_VAL(param->name)) - 1;				}				switch (PDO_PARAM_TYPE(param->param_type)) {					case PDO_PARAM_STMT:						return 0;					case PDO_PARAM_NULL:						if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {							return 1;						}						pdo_sqlite_error_stmt(stmt);						return 0;					case PDO_PARAM_INT:					case PDO_PARAM_BOOL:						if (Z_ISREF(param->parameter)) {							parameter = Z_REFVAL(param->parameter);						} else {							parameter = &param->parameter;						}						if (Z_TYPE_P(parameter) == IS_NULL) {							if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {								return 1;							}						} else {							convert_to_long(parameter);#if ZEND_LONG_MAX > 2147483647							if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) {								return 1;							}#else							if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) {								return 1;							}#endif						}						pdo_sqlite_error_stmt(stmt);						return 0;					case PDO_PARAM_LOB:						if (Z_ISREF(param->parameter)) {							parameter = Z_REFVAL(param->parameter);						} else {							parameter = &param->parameter;						}						if (Z_TYPE_P(parameter) == IS_RESOURCE) {							php_stream *stm = NULL;							php_stream_from_zval_no_verify(stm, parameter);							if (stm) {								zend_string *mem = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0);								zval_ptr_dtor(parameter);								ZVAL_STR(parameter, mem ? mem : ZSTR_EMPTY_ALLOC());							} else {								pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource");								return 0;							}						} else if (Z_TYPE_P(parameter) == IS_NULL) {							if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {								return 1;							}							pdo_sqlite_error_stmt(stmt);							return 0;						} else {							convert_to_string(parameter);						}						if (SQLITE_OK == sqlite3_bind_blob(S->stmt, param->paramno + 1,								Z_STRVAL_P(parameter),								Z_STRLEN_P(parameter),								SQLITE_STATIC)) {							return 1;						}						return 0;					case PDO_PARAM_STR:					default:						if (Z_ISREF(param->parameter)) {							parameter = Z_REFVAL(param->parameter);						} else {							parameter = &param->parameter;						}						if (Z_TYPE_P(parameter) == IS_NULL) {							if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {//.........这里部分代码省略.........

int SQLiteSTMT::BindInt(int iCol, int value) {  return sqlite3_bind_int(handle, iCol, value);}

intctdb_check_db_mode(struct ctdb_state *state){	sqlite3_stmt		*stmt;	char			*p, wanted;	int			rc, rv = 0, curgenid, ver = -1;	CNDBG(CT_LOG_DB, "ctdb mode %d/n", state->ctdb_crypt);	if (sqlite3_prepare_v2(state->ctdb_db,	    "SELECT crypto, version FROM mode", -1, &stmt, NULL)) {		CNDBG(CT_LOG_DB, "can't prepare mode query statement");		goto fail;	}	rc = sqlite3_step(stmt);	if (rc == SQLITE_DONE) {		CNDBG(CT_LOG_DB, "ctdb mode not found");		goto fail;	} else if (rc != SQLITE_ROW) {		CNDBG(CT_LOG_DB, "could not step(%d) %d %d %s",		    __LINE__, rc,		    sqlite3_extended_errcode(state->ctdb_db),		    sqlite3_errmsg(state->ctdb_db));		goto fail;	}	p = (char *)sqlite3_column_text(stmt, 0);	if (p) {		wanted =  state->ctdb_crypt ? 'Y' : 'N';		if (sqlite3_column_bytes(stmt, 0) != 1) {			CNDBG(CT_LOG_DB, "ctdb invalid length of column 1");			goto fail;		}		CNDBG(CT_LOG_DB, "ctdb crypto mode %c %c", p[0], wanted);		if (p[0] != wanted) {			CNDBG(CT_LOG_DB, "ctdb crypto mode differs %c %c",			    p[0], wanted);			goto fail;		}	}	/* early version of localdb didn't fill in version correctly */	if (sqlite3_column_type(stmt, 1) == SQLITE_NULL ||	    (ver = sqlite3_column_int(stmt, 1)) < CT_DB_VERSION) {		if (ctdb_upgrade_db(state, ver)) {			CNDBG(CT_LOG_DB,"failed to upgrade db!");			goto fail;		}	}	if (sqlite3_finalize(stmt)) {		CNDBG(CT_LOG_DB, "can't finalise statement");		goto fail;	}	if (sqlite3_prepare_v2(state->ctdb_db, "SELECT value FROM genid",	    -1, &stmt, NULL)) {		CNDBG(CT_LOG_DB, "old format db detected, reseting db");		goto fail;	}	rc = sqlite3_step(stmt);	if (rc == SQLITE_DONE) {		CNDBG(CT_LOG_DB, "ctdb genid not found");		goto fail;	} else if (rc != SQLITE_ROW) {		CNDBG(CT_LOG_DB, "could not step(%d) %d %d %s", __LINE__,		    rc, sqlite3_extended_errcode(state->ctdb_db),		    sqlite3_errmsg(state->ctdb_db));		goto fail;	}	curgenid = sqlite3_column_int(stmt, 0);	sqlite3_finalize(stmt);	stmt = NULL;	if (state->ctdb_genid == -1 || state->ctdb_genid == curgenid) {		state->ctdb_genid = curgenid;	} else if (state->ctdb_genid > curgenid) {		if (sqlite3_prepare(state->ctdb_db,		    "UPDATE genid SET value = ?", -1, &stmt, NULL)) {			CNDBG(CT_LOG_DB, "can't prepare update genid stmt");			goto fail;		}		if (sqlite3_bind_int(stmt, 1, state->ctdb_genid) != 0) {			CNDBG(CT_LOG_DB, "can't bind update genid stmt");			goto fail;		}		if (sqlite3_step(stmt) != SQLITE_DONE) {			CNDBG(CT_LOG_DB, "didn't get done on updating genid");			goto fail;		}		CNDBG(CT_LOG_DB, "updated genid from %d to %d",		    curgenid, state->ctdb_genid);	} else {		CNDBG(CT_LOG_DB, "ctdb genid is %d, wanted %d", curgenid,		    state->ctdb_genid);		goto fail;	}	CNDBG(CT_LOG_DB, "Mode check successful");	rv = 1;fail:	/* not much we can do if this fails */	if (stmt != NULL && sqlite3_finalize(stmt))//.........这里部分代码省略.........

intctdb_insert_sha(struct ctdb_state *state, uint8_t *sha_k, uint8_t *sha_v,    uint8_t *iv, int32_t genid){	char			shatk[SHA_DIGEST_STRING_LENGTH];	char			shatv[SHA_DIGEST_STRING_LENGTH];	int			rv, rc;	sqlite3_stmt		*stmt;	rv = 0;	if (state == NULL || state->ctdb_db == NULL)		return rv;	stmt = state->ctdb_stmt_insert;	if (state->ctdb_in_transaction == 0) {		if (ctdb_begin_transaction(state) != 0)			return (rv);		state->ctdb_trans_commit_rem = OPS_PER_TRANSACTION;	}	if (clog_mask_is_set(CT_LOG_DB)) {		ct_sha1_encode(sha_k, shatk);		if (sha_v == NULL)			shatv[0] = '/0';		else			ct_sha1_encode(sha_v, shatv);		CNDBG(CT_LOG_DB, "inserting for bin %s, %s", shatk, shatv);	}	if (sqlite3_bind_blob(stmt, 1, sha_k, SHA_DIGEST_LENGTH,	    SQLITE_STATIC)) {		CNDBG(CT_LOG_DB, "could not bind sha_k");		return rv;	}	if (state->ctdb_crypt) {		if (sha_v == NULL || iv == NULL)			CABORTX("crypt mode, but no sha_v/iv");		if (sqlite3_bind_blob(stmt, 2, sha_v,		    SHA_DIGEST_LENGTH, SQLITE_STATIC)) {			CNDBG(CT_LOG_DB, "could not bind sha_v");			sqlite3_reset(stmt);			return rv;		}		if (sqlite3_bind_blob(stmt, 3, iv,		    CT_IV_LEN, SQLITE_STATIC)) {			CNDBG(CT_LOG_DB, "could not bind iv ");			sqlite3_reset(stmt);			return rv;		}		if (sqlite3_bind_int(stmt, 4, genid) != 0) {			CNDBG(CT_LOG_DB, "could not bind genid");			sqlite3_reset(stmt);			return rv;		}	} else {		if (sqlite3_bind_int(stmt, 2, genid) != 0) {			CNDBG(CT_LOG_DB, "could not bind genid");			sqlite3_reset(stmt);			return rv;		}	}	rc = sqlite3_step(stmt);	if (rc == SQLITE_DONE) {		CNDBG(CT_LOG_DB, "insert completed");		rv = 1;	} else if (rc != SQLITE_CONSTRAINT) {		CNDBG(CT_LOG_DB, "insert failed %d %d [%s]", rc,		    sqlite3_extended_errcode(state->ctdb_db),		    sqlite3_errmsg(state->ctdb_db));	} else  {		CNDBG(CT_LOG_DB, "sha already exists");	}	sqlite3_reset(stmt);	/* inserts are more 'costly' than reads */	state->ctdb_trans_commit_rem -= 4;	if (state->ctdb_trans_commit_rem <= 0)		ctdb_end_transaction(state);	return rv;}

int										// returned identifier for transcriptCSQLiteDE::AddExpres(int ExprID,		// experiment identifier		int TransID,					// transcript identifier		int Class,		int Score,		int DECntsScore,		int PearsonScore,		int CtrlUniqueLoci,		int ExprUniqueLoci,		double CtrlExprLociRatio,		double PValueMedian,		double PValueLow95,		double PValueHi95,		int TotCtrlCnts,		int TotExprCnts,		int TotCtrlExprCnts,		double ObsFoldChange,		double FoldMedian,		double FoldLow95,		double FoldHi95,		double ObsPearson,		double PearsonMedian,		double PearsonLow95,		double PearsonHi95,		int CtrlAndExprBins,		int CtrlOnlyBins,		int ExprOnlyBins){tsDEStmSQL *pStm;int sqlite_error;int ExpresID;char szQueryExpresID[200];pStm = &m_StmSQL[2];								// access sequence statementsif((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 1, ExprID))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 2, TransID))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 3, Class))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 4, Score))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 5, DECntsScore))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 6, PearsonScore))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 7, CtrlUniqueLoci))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_int(pStm->pPrepInsert, 8, ExprUniqueLoci))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_double(pStm->pPrepInsert, 9, CtrlExprLociRatio))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_double(pStm->pPrepInsert, 10, PValueMedian))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);	}if((sqlite_error = sqlite3_bind_double(pStm->pPrepInsert, 11, PValueLow95))!=SQLITE_OK)	{	gDiagnostics.DiagOut(eDLFatal,gszProcName,"sqlite - bind prepared statement: %s", sqlite3_errmsg(m_pDB)); 	CloseDatabase(true);	return(eBSFerrInternal);//.........这里部分代码省略.........

static void bindIntParameter(sqlite3_stmt *stmt,const char *name,int value){  int idx = sqlite3_bind_parameter_index(stmt, name);  sqlite3_bind_int(stmt, idx, value);}

static void writeRelations(osm2olm* self, LCountry* country) {    Tree16 pseudoIndex;    initTree16(&pseudoIndex);    Tree16 whishesIndex;    initTree16(&whishesIndex);    int found;    printf("Writing relations for %s. Total relations: %i/n", country->polygon->name, self->relations.count);    int iterations = 0;    do {        found = 0;        for(int r = 0; r < self->relations.count; r++) {            if(!isInTree16(&pseudoIndex, self->relations.values[r].base.info.id)) {                if(self->relations.values[r].change != OSM_CHANGE_DELETE) {                    if((self->relations.values[r].change == OSM_CHANGE_NONE || relationBelongsCountry(self->relations.values + r, country, &pseudoIndex))) {                        addTree16Node(&pseudoIndex, self->relations.values[r].base.info.id, 0);                                                found++;                    } else {                        if(self->relations.values[r].change != OSM_CHANGE_NONE) {                            printf("Relation %i does not belongs country/n", self->relations.values[r].base.info.id);                        } else {                            printf("Relation %i exists in DB and was'nt changed/n", self->relations.values[r].base.info.id);                        }                                            }                } else {                    printf("Relation %i was deleted/n", self->relations.values[r].base.info.id);                }            } else {                //printf("Relation %i already encountered/n", self->relations.values[r].base.info.id);            }        }        iterations++;    } while(found);    printf("Relations found in %i iterations/n", iterations);    int written = 0;    for(int r=0;r < self->relations.count; r++) {        if(isInTree16(&pseudoIndex, self->relations.values[r].base.info.id)){            beginTransaction(country->db);            addTree16Node(&(country->relationsIndex), self->relations.values[r].base.info.id, self->relations.values[r].base.info.id);            switch (self->relations.values[r].change) {                case OSM_CHANGE_CREATE:                    sqlite3_bind_int(country->insertRelationStatement, 1, self->relations.values[r].base.info.id);                    sqlite3_bind_int64(country->insertRelationStatement, 2, self->relations.values[r].base.info.timestamp);                    sqlite3_step(country->insertRelationStatement);                    sqlite3_reset(country->insertRelationStatement);                    writeTags(self, &(self->relations.values[r].base.tags), country->insertRelationTagStatement, self->relations.values[r].base.info.id);                    writeRelationMember(self->relations.values + r, country);                    break;                case OSM_CHANGE_DELETE:                    deleteRelationFromCountry(country, self->relations.values[r].base.info.id);                case OSM_CHANGE_MODIFY:                    sqlite3_bind_int(country->insertRelationStatement, 1, self->relations.values[r].base.info.id);                    sqlite3_bind_int64(country->insertRelationStatement, 2, self->relations.values[r].base.info.timestamp);                    sqlite3_step(country->insertRelationStatement);                    sqlite3_reset(country->insertRelationStatement);                    deleteFromDbById(country->db, country->deleteRelationTagsStatement, self->relations.values[r].base.info.id);                    writeTags(self, &(self->relations.values[r].base.tags), country->insertRelationTagStatement, self->relations.values[r].base.info.id);                    deleteFromDbById(country->db, country->deleteRelationMembersStatement, self->relations.values[r].base.info.id);                    writeRelationMember(self->relations.values + r, country);                    break;                case OSM_CHANGE_COUNT:                case OSM_CHANGE_NONE:                    //Just do nothing, as db is up to date                    break;                                }            commitTransaction(country->db);            written++;        } else {            deleteRelationFromCountry(country, self->relations.values[r].base.info.id);            //printf("Skip relation %i. %s/n", self->relations.values[r].info.id, isInTree16(&pseudoIndex, self->relations.values[r].info.id) ? (relationIsFullyBelongsCountry(self->relations.values + r, country, &pseudoIndex)? "HM.." : "It does not have some members.") : "it is not in list");        }    }    freeTree16(&pseudoIndex);    printf("Relations written: %i/n", written);}

/*Update write/read times for both wind and unwind*/static inline intgf_update_time (gf_sql_connection_t    *sql_conn,                char                    *gfid,                gfdb_time_t             *update_time,                gf_boolean_t            record_counter,                gf_boolean_t            is_wind,                gf_boolean_t            is_read){        int ret = -1;        sqlite3_stmt *update_stmt = NULL;        char update_str[1024] = "";        char *freq_cntr_str = NULL;        CHECK_SQL_CONN (sql_conn, out);        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, update_time, out);        /*         * Constructing the prepare statment string.         *         * */        /*For write time*/        if (!is_read) {                if (is_wind) {                        /*if record counter is on*/                        freq_cntr_str = (record_counter) ?                        ", WRITE_FREQ_CNTR = WRITE_FREQ_CNTR + 1" : "";                        /*Prefectly safe as we will not go array of bound*/                        sprintf (update_str, "UPDATE "                                GF_FILE_TABLE                                " SET W_SEC = ?, W_MSEC = ? "                                " %s"/*place for read freq counters*/                                " WHERE GF_ID = ? ;", freq_cntr_str);                } else {                        /*Prefectly safe as we will not go array of bound*/                        sprintf (update_str, "UPDATE "                                GF_FILE_TABLE                                " SET UW_SEC = ?, UW_MSEC = ? ;");                }        }        /*For Read Time update*/        else {                if (is_wind) {                        /*if record counter is on*/                        freq_cntr_str = (record_counter) ?                        ", READ_FREQ_CNTR = READ_FREQ_CNTR + 1" : "";                        /*Prefectly safe as we will not go array of bound*/                        sprintf (update_str, "UPDATE "                                GF_FILE_TABLE                                " SET W_READ_SEC = ?, W_READ_MSEC = ? "                                " %s"/*place for read freq counters*/                                " WHERE GF_ID = ? ;", freq_cntr_str);                } else {                        /*Prefectly safe as we will not go array of bound*/                        sprintf (update_str, "UPDATE "                                GF_FILE_TABLE                                " SET UW_READ_SEC = ?, UW_READ_MSEC = ? ;");                }        }        /*Prepare statement*/        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, update_str, -1,                                &update_stmt, 0);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_PREPARE_FAILED, "Failed preparing insert "                        "statment %s : %s", update_str,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Bind time secs*/        ret = sqlite3_bind_int (update_stmt, 1, update_time->tv_sec);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "                        "secs %ld : %s", update_time->tv_sec,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Bind time msecs*/        ret = sqlite3_bind_int (update_stmt, 2, update_time->tv_usec);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "                        "msecs %ld : %s", update_time->tv_usec,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Bind gfid*/        ret = sqlite3_bind_text (update_stmt, 3, gfid, -1, NULL);        if (ret != SQLITE_OK) {//.........这里部分代码省略.........

static intgf_sql_insert_write_wind_time (gf_sql_connection_t  *sql_conn,                                char                 *gfid,                                gfdb_time_t          *wind_time){        int ret = -1;        sqlite3_stmt *insert_stmt = NULL;        char *insert_str = "INSERT INTO "                           GF_FILE_TABLE                           "(GF_ID, W_SEC, W_MSEC, UW_SEC, UW_MSEC)"                           " VALUES (?, ?, ?, 0, 0);";        CHECK_SQL_CONN (sql_conn, out);        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, gfid, out);        GF_VALIDATE_OR_GOTO (GFDB_STR_SQLITE3, wind_time, out);        /*Prepare statement*/        ret = sqlite3_prepare (sql_conn->sqlite3_db_conn, insert_str, -1,                        &insert_stmt, 0);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_PREPARE_FAILED, "Failed preparing insert "                        "statment %s : %s", insert_str,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Bind gfid*/        ret = sqlite3_bind_text (insert_stmt, 1, gfid, -1, NULL);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_BINDING_FAILED, "Failed binding gfid %s : %s",                        gfid, sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Bind wind secs*/        ret = sqlite3_bind_int (insert_stmt, 2, wind_time->tv_sec);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "                        "secs %ld : %s", wind_time->tv_sec,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Bind wind msecs*/        ret = sqlite3_bind_int (insert_stmt, 3, wind_time->tv_usec);        if (ret != SQLITE_OK) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0,                        LG_MSG_BINDING_FAILED, "Failed binding parent wind "                        "msecs %ld : %s", wind_time->tv_usec,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        /*Execute the prepare statement*/        if (sqlite3_step (insert_stmt) != SQLITE_DONE) {                gf_msg (GFDB_STR_SQLITE3, GF_LOG_ERROR, 0, LG_MSG_EXEC_FAILED,                        "Failed executing the prepared stmt GFID:%s %s : %s",                        gfid, insert_str,                        sqlite3_errmsg (sql_conn->sqlite3_db_conn));                ret = -1;                goto out;        }        ret = 0;out:        /*Free prepared statement*/        sqlite3_finalize (insert_stmt);        return ret;}

//.........这里部分代码省略.........    {        fputs ("could not prepare basic statement; game database file may be corrupt:/n", stderr);        fputs (sqlite3_errmsg(database), stderr);        fputs ("/n", stderr);        return 2;    }    if (sqlite3_prepare_v2(database, "select group_concat(diff,'') from voutputansi;", -1, &statementDisplay, 0) != SQLITE_OK)    {        fputs ("could not prepare basic statement; game database file may be corrupt:/n", stderr);        fputs (sqlite3_errmsg(database), stderr);        fputs ("/n", stderr);        return 3;    }    if (sqlite3_prepare_v2(database, "insert into vkeypress (key) values (?1);", -1, &statementInsertKeypress, 0) != SQLITE_OK)    {        fputs ("could not prepare basic statement; game database file may be corrupt:/n", stderr);        fputs (sqlite3_errmsg(database), stderr);        fputs ("/n", stderr);        return 5;    }    tcgetattr (0, &orig);    tcgetattr (0, &raw);    cfmakeraw (&raw);    tcsetattr (0, 0, &raw);    ioctl(0, TIOCGWINSZ, &size);    puts("/e[2J/e[?25l");    sqlite3_bind_int (statementUpdateDisplaySize, 1, size.ws_col);    sqlite3_bind_int (statementUpdateDisplaySize, 2, size.ws_row);    if (sqlite3_step(statementUpdateDisplaySize) != SQLITE_DONE)    {        fputs(sqlite3_errmsg(database), stderr);    }    sqlite3_reset(statementUpdateDisplaySize);    do    {        int r;        char key;        while ((r = sqlite3_step(statementDisplay)) == SQLITE_ROW)        {            const char *output = (const char*)sqlite3_column_text(statementDisplay, 0);            if (output != 0)            {                puts(output);            }            else            {                fputs(sqlite3_errmsg(database), stderr);            }        }        if (r != SQLITE_DONE)        {            fputs(sqlite3_errmsg(database), stderr);        }        sqlite3_reset(statementDisplay);