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

void SQLiteGateWriterImpl::writeMatrixToDB(std::string label, MatrixPtr pMatrix) {	std::string matrixValStr = getMatrixValueString(pMatrix);	int rc = sqlite3_bind_text(m_pStatement, 1, label.c_str(), -1, SQLITE_STATIC);	if(rc != SQLITE_OK) {		fprintf(stderr, "Error 1 %s due to %s/n", sqlite3_errmsg(m_pDb), sqlite3_errstr(rc));		throw (rc);	}	rc = sqlite3_bind_text(m_pStatement, 2, matrixValStr.c_str(), -1, SQLITE_STATIC);	if(rc != SQLITE_OK) {		fprintf(stderr, "Error 2 %s due to %s/n", sqlite3_errmsg(m_pDb), sqlite3_errstr(rc));		throw (rc);	}	int result = sqlite3_step(m_pStatement);	//Don't consider violate constrainst such as unique label a serious error	//to forgive attempts add duplicated matrix	if(result != SQLITE_DONE && result != SQLITE_CONSTRAINT) {		fprintf(stderr, "Error 3 %s due to %s/n", sqlite3_errmsg(m_pDb), sqlite3_errstr(result));		throw (result);	}	sqlite3_reset(m_pStatement);}

	bool Database::Open(const std::string &Path)	{		if (Inner != nullptr)			Close();		int Err;		if ((Err = sqlite3_initialize()) != SQLITE_OK)			return LogError(sqlite3_errstr(Err), false);		if (Err = sqlite3_open_v2(Path.c_str(), &Inner, SQLITE_OPEN_READWRITE, nullptr) != SQLITE_OK)		{			if (Err = sqlite3_open_v2(Path.c_str(), &Inner, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, nullptr) != SQLITE_OK)				return LogError(sqlite3_errstr(Err), false);			std::vector<std::string> TableStrings;			TableStrings.push_back(User::CreationString);			TableStrings.push_back(Server::CreationString);			TableStrings.push_back(Chatroom::CreationString);			for (unsigned int x = 0; x < TableStrings.size(); x++)			{				Statement s;				if (!s.Prepare(Inner, TableStrings[x]))					return false;				if (!s.Execute())					return false;			}		}		return true;	}

static int prepare_statements(void){	int ret;#define	FIND_TOP_HASHES							/"select digest, count(digest) from hashes group by digest having (count(digest) > 1) order by (count(digest)) desc;"	ret = sqlite3_prepare_v2(gdb, FIND_TOP_HASHES, -1, &top_hashes_stmt,				 NULL);	if (ret) {		fprintf(stderr, "error %d while prepping hash search stmt: %s/n",			ret, sqlite3_errstr(ret));		return ret;	}#define	FIND_FILES_COUNT						/"select count (distinct files.filename) from files INNER JOIN hashes on hashes.digest = ?1 AND files.subvol=hashes.subvol AND files.ino=hashes.ino;"	ret = sqlite3_prepare_v2(gdb, FIND_FILES_COUNT, -1, &files_count_stmt,				 NULL);	if (ret) {		fprintf(stderr, "error %d while preparing file count stmt: %s/n",			ret, sqlite3_errstr(ret));		return ret;	}#define	FIND_BLOCKS							/"select files.filename, hashes.loff, hashes.flags from files INNER JOIN hashes on hashes.digest = ?1 AND files.subvol=hashes.subvol AND files.ino=hashes.ino;"	ret = sqlite3_prepare_v2(gdb, FIND_BLOCKS, -1, &find_blocks_stmt, NULL);	if (ret) {		fprintf(stderr, "error %d while prepping find blocks stmt: %s/n",			ret, sqlite3_errstr(ret));		return ret;	}	return 0;}

void SqliteConnection::open() {    int code = sqlite3_open(fileName_.c_str(), &handle_);    if (code != SQLITE_OK) {        SERVICE_LOG_LVL(ERROR, "SqliteConnection::open: cannot connect to file: " << fileName_                << ". Error code: " << code << " Description: " << sqlite3_errstr(code));        throw SqliteConnectionException(sqlite3_errstr(code));    }    connected_ = true;}

void SqliteConnection::close() {    if (handle_) {        for (auto callback: onCloseCallbacks_)            callback(this);        int code = sqlite3_close(handle_);        handle_ = nullptr;        connected_ = false;        if (code != SQLITE_OK) {            SERVICE_LOG_LVL(ERROR, "SqliteConnection::close: cannot close db file: " << fileName_                    << ". Error code: " << code << " Description: " << sqlite3_errstr(code));            throw SqliteConnectionException(sqlite3_errstr(code));        }    }}

extern void new_word(char *w, int slideid, char origin, short kw) {    int code = SQLITE_DONE;    if (w) {      (void)sqlite3_reset(G_ins_word);      if ((sqlite3_bind_text(G_ins_word, 1, w, -1, NULL) == SQLITE_OK)          && (sqlite3_bind_int(G_ins_word, 2, slideid) == SQLITE_OK)          && (sqlite3_bind_int(G_ins_word, 3, (int)origin) == SQLITE_OK)          && (sqlite3_bind_int(G_ins_word, 4, (int)kw) == SQLITE_OK)          && ((code = sqlite3_step(G_ins_word)) == SQLITE_DONE)) {        return;       }      (void)sqlite3_reset(G_upd_word);      if ((sqlite3_bind_text(G_upd_word, 1, w, -1, NULL) == SQLITE_OK)        && (sqlite3_bind_int(G_upd_word, 2, slideid) == SQLITE_OK)        && ((code = sqlite3_step(G_upd_word)) == SQLITE_DONE)) {        return;       }      fprintf(stderr,              "update word: %s (%d/code %d - %s)/n",              (char *)sqlite3_errmsg(G_db),              sqlite3_errcode(G_db),              code,              sqlite3_errstr(code));    }}

 std::string Database::errorDescription(int code) const {     if (!isOpening()) {         return sqlite3_errstr(code);     }          return sqlite3_errmsg(_db); }

	bool Statement::Reset()	{		int Err = sqlite3_reset(Inner);		if (Err != SQLITE_OK)		{			LogError("Failed to reset statement.");			return LogError(sqlite3_errstr(Err), false);		}		Err = sqlite3_clear_bindings(Inner);		if (Err != SQLITE_OK)		{			LogError("Failed to clear bindings.");			return LogError(sqlite3_errstr(Err), false);		}		return true;	}

// Execute a one-step query with no expected resultint Statement::exec(){    if (false == mbDone)    {        const int ret = sqlite3_step(mStmtPtr);        if (SQLITE_DONE == ret) // the statement has finished executing successfully        {            mbOk = false;            mbDone = true;        }        else if (SQLITE_ROW == ret)        {            mbOk = false;            mbDone = false;            throw SQLite::Exception("exec() does not expect results. Use executeStep.");        }        else        {            mbOk = false;            mbDone = false;            throw SQLite::Exception(sqlite3_errstr(ret));        }    }    else    {        throw SQLite::Exception("Statement need to be reseted.");    }    // Return the number of rows modified by those SQL statements (INSERT, UPDATE or DELETE)    return sqlite3_changes(mStmtPtr);}

vmod_exec(const struct vrt_ctx *ctx, struct vmod_priv *priv, VCL_STRING sql){	struct vmod_sqlite3_result r;	struct vmod_sqlite3 *v;	char *e, *p;	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);	AN(priv);	if (!priv->priv) {		e = (char *)sqlite3_errstr(SQLITE_ERROR);		p = WS_Copy(ctx->ws, e, -1);		return (p);	}	CAST_OBJ_NOTNULL(v, priv->priv, VMOD_SQLITE3_MAGIC);	r.u = WS_Reserve(ctx->ws, 0);	r.p = ctx->ws->f;	r.d = v->d;	r.l = 0;	r.r = 0;	*(r.p) = '/0';	if (sqlite3_exec(v->db, sql, vmod_exec_cb, &r, &e) != SQLITE_OK) {		WS_Release(ctx->ws, 0);		p = WS_Copy(ctx->ws, e, -1);		sqlite3_free(e);		return (p);	}	WS_Release(ctx->ws, r.l + 1);	return (r.p);}

extern void new_word_as_is(char *w, int slideid, char origin, short kw) {    int   code = SQLITE_DONE;    char *t;    if (w && ((t = cleanup(w)) != (char *)NULL)) {      (void)sqlite3_reset(G_ins_word_as_is);      if ((sqlite3_bind_text(G_ins_word_as_is, 1, t, -1, NULL) == SQLITE_OK)          && (sqlite3_bind_int(G_ins_word_as_is, 2, slideid) == SQLITE_OK)          && (sqlite3_bind_int(G_ins_word_as_is, 3, (int)origin) == SQLITE_OK)          && (sqlite3_bind_int(G_ins_word_as_is, 4, (int)kw) == SQLITE_OK)          && ((code = sqlite3_step(G_ins_word_as_is)) == SQLITE_DONE)) {        return;       }      (void)sqlite3_reset(G_upd_word_as_is);      if ((sqlite3_bind_text(G_upd_word_as_is, 1, t, -1, NULL) == SQLITE_OK)        && (sqlite3_bind_int(G_upd_word_as_is, 2, slideid) == SQLITE_OK)        && ((code = sqlite3_step(G_upd_word_as_is)) == SQLITE_DONE)) {        return;       }      if (t) {        free(t);      }      fprintf(stderr,              "update word: %s (%d/code %d - %s)/n",              (char *)sqlite3_errmsg(G_db),              sqlite3_errcode(G_db),              code,              sqlite3_errstr(code));    }}

int sqliterkCryptoDecode(sqliterk_codec *codec, int pgno, void *data){    int rc;    int offset = 0;    unsigned char *pdata = (unsigned char *) data;    int page_sz = sqlcipher_codec_ctx_get_pagesize(codec);    unsigned char *buffer =        (unsigned char *) sqlcipher_codec_ctx_get_data(codec);    rc = sqlcipher_codec_key_derive(codec);    if (rc != SQLITE_OK)        return rc;    if (pgno == 1) {        offset = 16; // FILE_HEADER_SZ        memcpy(buffer, "SQLite format 3", 16);    }    rc = sqlcipher_page_cipher(codec, CIPHER_READ_CTX, pgno, CIPHER_DECRYPT,                               page_sz - offset, pdata + offset,                               buffer + offset);    if (rc != SQLITE_OK)        goto bail;    memcpy(pdata, buffer, page_sz);    return SQLITERK_OK;bail:    sqliterkOSError(SQLITERK_DAMAGED, "Failed to decode page %d: %s", pgno,                    sqlite3_errstr(rc));    return rc;}

std::string err_str_(int rc){#if SQLITE_VERSION_NUMBER < 3007015    return std::to_string(rc);#else    return sqlite3_errstr(rc);#endif}

Cache::~Cache() {    if (db) {        int retVal = sqlite3_close_v2(db);        if( SQLITE_OK != retVal ) {            std::cerr << "Oops: failed to properly close database: " << sqlite3_errstr(retVal) << std::endl;        }    }}

BindException::BindException(sqlite3_stmt* statement, const std::string& parameter, int resultCode) {    const auto errorString = sqlite3_errstr(resultCode);    const auto query = sqlite3_sql(statement);    std::stringstream what;    what << errorString << " (" << resultCode << ") for parameter /"" << parameter << "/" of query /"" << query << "/"";    m_what = what.str();}

SqliteException::SqliteException(const std::string &func, int resultCode)    : Exception(          std::string("[") + func + "] " +          resultToResultName(resultCode) +          " (" + sqlite3_errstr(resultCode) + ")"          ){}

 void object::close () {     if (context)     {         error = sqlite3_close_v2 (context);         if (error != SQLITE_OK)             LOG_ERROR("database close error (%s)", sqlite3_errstr (error));     } }

// Execute backup step with a given number of source pages to be copiedint Backup::executeStep(const int aNumPage /* = -1 */){    const int res = sqlite3_backup_step(mpSQLiteBackup, aNumPage);    if (SQLITE_OK != res && SQLITE_DONE != res && SQLITE_BUSY != res && SQLITE_LOCKED != res)    {        throw SQLite::Exception(sqlite3_errstr(res), res);    }    return res;}

bool Cache::prepSqlite(const std::string &query) {    int retVal = sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, NULL);    if(SQLITE_OK != retVal) {        std::cerr << "Failed to prepare statement: " << query << " - Message:" << sqlite3_errstr(retVal) << std::endl;        return false;    }    return true;}

static void db_statement_finalize(sqlite3_stmt *ppstmt){    int retval = sqlite3_finalize(ppstmt);    if (SQLITE_OK != retval)    {	printlog("ERROR: finalizing sql statement: %s", sqlite3_errstr(retval));	qexit(EXIT_FAILURE);    }}

bool Cache::finalizeSqlite() {    int retVal = sqlite3_finalize(stmt);    if(SQLITE_OK != retVal) {        std::cerr << "Unable to finalize: " << sqlite3_errstr(retVal) << std::endl;        return false;    }    return true;}

bool Cache::initSqlite() {    int retVal = sqlite3_initialize();    if(SQLITE_OK != retVal) {        std::cerr << "Can't initialize sqlite3: " << sqlite3_errstr(retVal) << std::endl;        return false;    }    return true;}

bool Cache::stepSqlite(const std::string &errMsg) {    int retVal = sqlite3_step(stmt);    if(SQLITE_DONE != retVal) {        std::cerr << errMsg << ": " << sqlite3_errstr(retVal) << std::endl;        return false;    }    return true;}

intmain( int argc, char *argv[] ){  /* open the database */  int result = sqlite3_open( dbname, &db );  int maxid;  if ( result != SQLITE_OK )  {    printf( "Failed to open database %s/n/r", sqlite3_errstr( result ) );    sqlite3_close( db );    return 1;  }  printf( "Opened db %s OK/n/r", dbname );  maxid = getmaxidevent(  );  /* prepare the insert sql, leave stmt ready for loop */  result = sqlite3_prepare_v2( db, insert_sql, strlen( insert_sql ) + 1, &stmt, NULL );  if ( result != SQLITE_OK )  {    printf( "Failed to prepare database %s/n/r", sqlite3_errstr( result ) );    sqlite3_close( db );    return 2;  }  printf( "SQL prepared ok/n/r" );  /* bind parameters */  sqlite3_bind_int( stmt, 1, maxid ); /* best done by autoincreement */  sqlite3_bind_int( stmt, 2, 41456 ); /* date */  sqlite3_bind_int( stmt, 3, 4 ); /* idvenue 4 = Echo */  sqlite3_bind_int( stmt, 4, 1 ); /* ideventtype - disco */  sqlite3_bind_text( stmt, 5, description, strlen( description ), SQLITE_STATIC );  printf( "Before - maxid = %d/n/r", maxid );  /* insert row by running one stmt */  result = sqlite3_step( stmt );  maxid = getmaxidevent(  );  printf( "After - maxid = %d/n/r", maxid );  /* finish off */  sqlite3_close( db );  return 0;}

bool index_insert_entry(   fp_data& fpd,   UINT32 line,   UINT32 column_start,   const char *scope,   id_type type,   id_sub_type sub_type,   const char *identifier){   bool retval = true;   int result;   sqlite3_stmt *stmt_insert_entry = cpd.stmt_insert_reference;   if (sub_type == IST_DEFINITION)      stmt_insert_entry = cpd.stmt_insert_definition;   else if (sub_type == IST_DECLARATION)      stmt_insert_entry = cpd.stmt_insert_declaration;   result = sqlite3_bind_int64(stmt_insert_entry,                               2,                               line);   result |= sqlite3_bind_int64(stmt_insert_entry,                                3,                                column_start);   result |= sqlite3_bind_text(stmt_insert_entry,                               4,                               scope,                               -1,                               SQLITE_STATIC);   result |= sqlite3_bind_int(stmt_insert_entry,                              5,                              (int) type);   result |= sqlite3_bind_text(stmt_insert_entry,                               6,                               identifier,                               -1,                               SQLITE_STATIC);   if (result == SQLITE_OK)   {      result = sqlite3_step(stmt_insert_entry);      if (result == SQLITE_DONE)      {         result = sqlite3_reset(stmt_insert_entry);      }   }   if (result != SQLITE_OK)   {      const char *errstr = sqlite3_errstr(result);      LOG_FMT(LERR, "index_insert_entry: access error (%d: %s)/n", result, errstr != NULL ? errstr : "");      retval = false;   }   return retval;}

void save_from_memory_to_file(const String &fn, sqlite3 *db){    auto ret = loadOrSaveDb(db, fn.c_str(), 1);    if (ret != SQLITE_OK)    {        String error = "Can't save database: " + fn + " error: " + sqlite3_errstr(ret);        sqlite3_close(db);        throw std::runtime_error(error);    }}

	bool Statement::Execute()	{		int Err = sqlite3_step(Inner);		if (Err != SQLITE_DONE)		{			Finalise();			return LogError(sqlite3_errstr(Err), false);		}		return true;	}

	bool Statement::Finalise()	{		int Err = sqlite3_finalize(Inner);		if (Err != SQLITE_OK)		{			LogError("Failed to finalise statement.");			return LogError(sqlite3_errstr(Err), false);		}		Inner = nullptr;		return true;	}