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

// methods for formatting// ---------------------------------------------std::string SqliteDatabase::vprepare(const char *format, va_list args){  std::string strFormat = format;  std::string strResult = "";  char *p;  size_t pos;  //  %q is the sqlite format string for %s.  //  Any bad character, like "'", will be replaced with a proper one  pos = 0;  while ( (pos = strFormat.find("%s", pos)) != std::string::npos )    strFormat.replace(pos++, 2, "%q");  //  the %I64 enhancement is not supported by sqlite3_vmprintf  //  must be %ll instead  pos = 0;  while ( (pos = strFormat.find("%I64", pos)) != std::string::npos )    strFormat.replace(pos++, 4, "%ll");  p = sqlite3_vmprintf(strFormat.c_str(), args);  if ( p )  {    strResult = p;    sqlite3_free(p);  }  return strResult;}

/** * A query that can't retrieve results */static gbooleanxmms_sqlite_exec (sqlite3 *sql, const char *query, ...){	gchar *q, *err;	va_list ap;	gint ret;	g_return_val_if_fail (query, FALSE);	g_return_val_if_fail (sql, FALSE);	va_start (ap, query);	q = sqlite3_vmprintf (query, ap);	ret = sqlite3_exec (sql, q, NULL, NULL, &err);	if (ret == SQLITE_BUSY) {			printf ("BUSY EVENT!");			g_assert_not_reached ();	}	if (ret != SQLITE_OK) {			printf ("Error in query! /"%s/" (%d) - %s", q, ret, err);			sqlite3_free (q);			va_end (ap);			return FALSE;	}	sqlite3_free (q);	va_end (ap);	return TRUE;}

int Database::execute(const char *sql_fmt, ...){  if (!m_db) return false;  if (m_result_table) finalize();  va_list ap;  va_start(ap, sql_fmt);  char *sql = sqlite3_vmprintf(sql_fmt, ap);  va_end(ap);  if (!sql) {    fprintf(stderr, "can't allocate memory for sql statement!/n");    return 0;  }  m_result_table = NULL;  m_curr_row = 0;  if (sqlite3_get_table(m_db, sql, &m_result_table, &m_rows, &m_cols, &m_error) != SQLITE_OK) {    debug("error executing SQL query (%s): %s/n", sql, m_error);    finalize();    sqlite3_free(sql);    return 0;  }  sqlite3_free(sql);  m_curr_row = 1;  return m_rows;}

const char* cSQLiteDatabase::sprintf(const char* Format, ...){    va_list vlist;    va_start(vlist, Format);    char* SQLStatement = sqlite3_vmprintf(Format, vlist);    va_end(vlist);    return SQLStatement;}

/*** Print an error message and then quit.*/static void fatalError(const char *zFormat, ...){  va_list ap;  char *zMsg;  char zPrefix[30];  va_start(ap, zFormat);  zMsg = sqlite3_vmprintf(zFormat, ap);  va_end(ap);  sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:FATAL: ", g.zName);  if( g.pLog ){    printWithPrefix(g.pLog, zPrefix, zMsg);    fflush(g.pLog);    maybeClose(g.pLog);  }  if( g.pErrLog && safe_strcmp(g.zErrLog,g.zLog) ){    printWithPrefix(g.pErrLog, zPrefix, zMsg);    fflush(g.pErrLog);    maybeClose(g.pErrLog);  }  sqlite3_free(zMsg);  if( g.db ){    int nTry = 0;    g.iTimeout = 0;    while( trySql("UPDATE client SET wantHalt=1;")==SQLITE_BUSY           && (nTry++)<100 ){      sqlite3_sleep(10);    }  }  sqlite3_close(g.db);  exit(1);  }

intsql_get_int_field(sqlite3 *db, const char *fmt, ...){	va_list		ap;	int		counter, result;	char		*sql;	int		ret;	sqlite3_stmt	*stmt;		va_start(ap, fmt);	sql = sqlite3_vmprintf(fmt, ap);	//DPRINTF(E_DEBUG, L_DB_SQL, "sql: %s/n", sql);	switch (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL))	{		case SQLITE_OK:			break;		default:			DPRINTF(E_ERROR, L_DB_SQL, "prepare failed: %s/n", sqlite3_errmsg(db));			sqlite3_free(sql);			return -1;	}	sqlite3_free(sql);	for (counter = 0;	     ((result = sqlite3_step(stmt)) == SQLITE_BUSY || result == SQLITE_LOCKED) && counter < 2;	     counter++) {		 /* While SQLITE_BUSY has a built in timeout,		    SQLITE_LOCKED does not, so sleep */		 if (result == SQLITE_LOCKED)		 	sleep(1);	}	switch (result)	{		case SQLITE_DONE:			/* no rows returned */			ret = 0;			break;		case SQLITE_ROW:			if (sqlite3_column_type(stmt, 0) == SQLITE_NULL)			{				ret = 0;				break;			}			ret = sqlite3_column_int(stmt, 0);			break;		default:			DPRINTF(E_WARN, L_DB_SQL, "%s: step failed: %s/n", __func__, sqlite3_errmsg(db));			ret = -1;			break; 	}	sqlite3_finalize(stmt);	return ret;}

/** * DB_exec will run a SQL query, using the sqlite3_mprintf syntax, and * convert the results to a tns_value_t* that you can use.  It returns * one of four types of results: * * - tns_tag_null -- The query wasn't expected to return anything, like UPDATE. * - tns_tag_list(empty) -- The query expected to return rows, but nothing returned. * - tns_tag_list -- There's rows that resulted from the query. * - NULL -- There was an error processing your query. * * You own the row and everything in it, and you should know what the columns * are, but they are tagged properly for each type that comes from the query. */tns_value_t *DB_exec(const char *query, ...){    va_list argp;    va_start(argp, query);    char *zErrMsg = NULL;    tns_value_t *res = NULL;    int rc = 0;    sqlite3_stmt *stmt = NULL;    const char *sql_tail = NULL;    char *sql = NULL;    check(CONFIG_DB != NULL, "The config database is not open.");    sql = sqlite3_vmprintf(query, argp);    check_mem(sql);      rc = sqlite3_prepare_v2(CONFIG_DB, sql, -1, &stmt, &sql_tail);    check(rc == SQLITE_OK, "SQL error /"%s/" at: '%s'", sqlite3_errmsg(CONFIG_DB), sql_tail);    // we want to return a tns_tag_null if this is a query with no    // results, which means we have to do a little bit of weird logic    rc = sqlite3_step(stmt);    if(rc == SQLITE_DONE) {        if(sqlite3_column_count(stmt) == 0) {            // query like UPDATE with no results possible            res = tns_get_null();        } else {            // query that had results possible but had none            res = tns_new_list();        }    } else if(rc == SQLITE_ROW) {        // query with results, process them        res = tns_new_list();        do {            tns_value_t *row = DB_convert_column(stmt);            check(row != NULL, "Failed to convert DB column for sql: '%s'", sql);            tns_add_to_list(res, row);        } while((rc = sqlite3_step(stmt)) == SQLITE_ROW);    }    check(rc != SQLITE_ERROR, "Failure executing sql: %s", sqlite3_errmsg(CONFIG_DB));       sqlite3_free(sql);    sqlite3_finalize(stmt);    va_end(argp);    return res;error:    va_end(argp);    if(stmt) sqlite3_finalize(stmt);    if(zErrMsg) sqlite3_free(zErrMsg);    if(sql) sqlite3_free(sql);    if(res) tns_value_destroy(res);    return NULL;}

static void geom_tls_msg_handler(const char *fmt, ...) {  geom_geos_clear_error();  va_list args;  va_start(args, fmt);  char *err = sqlite3_vmprintf(fmt, args);  GPKG_TLS_SET(last_geos_error, err);  va_end(args);}

const char* CppSQLite3Buffer::format(const char* szFormat, ...){	clear();	va_list va;	va_start(va, szFormat);	mpBuf = sqlite3_vmprintf(szFormat, va);	va_end(va);	return mpBuf;}

void reg_throw(reg_error* errPtr, char* code, char* fmt, ...) {    va_list list;    va_start(list, fmt);    errPtr->description = sqlite3_vmprintf(fmt, list);    va_end(list);    errPtr->code = code;    errPtr->free = (reg_error_destructor*)sqlite3_free;}

  int database::executef(char const* sql, ...)  {    va_list ap;    va_start(ap, sql);    char* msql = sqlite3_vmprintf(sql, ap);    va_end(ap);    return execute(msql);  }

static void asyncTrace(const char *zFormat, ...){  char *z;  va_list ap;  va_start(ap, zFormat);  z = sqlite3_vmprintf(zFormat, ap);  va_end(ap);  fprintf(stderr, "[%d] %s", (int)pthread_self(), z);  sqlite3_free(z);}

    int database::executef(char const* sql, ...)    {        va_list ap;        va_start(ap, sql);        std::unique_ptr<char, void (*)(void *)> msql(sqlite3_vmprintf(sql, ap), sqlite3_free);        va_end(ap);        return eexecute(msql.get());    }

  int database::executef(char const* sql, ...)  {    va_list ap;    va_start(ap, sql);    boost::shared_ptr<char> msql(sqlite3_vmprintf(sql, ap), sqlite3_free);    va_end(ap);    return execute(msql.get());  }

// Same but accepts a va_listvoid SqlDatabase::sqlExecVar(const char* szSQL, va_list args) {	require(mpDB);	char* szSqlFormatted = sqlite3_vmprintf(szSQL, args);	if (!szSqlFormatted)		throw new SqlDatabaseException("Unable to apply format to SQL string");	const int result = sqlite3_exec(mpDB, szSqlFormatted, 0, 0, 0);	sqlite3_free(szSqlFormatted);	if (result != SQLITE_OK)		throw new SqlDatabaseException(sqlite3_errmsg(mpDB));}

/*** Try to run arbitrary SQL.  Return success code.*/static int trySql(const char *zFormat, ...){  va_list ap;  char *zSql;  int rc;  va_start(ap, zFormat);  zSql = sqlite3_vmprintf(zFormat, ap);  va_end(ap);  rc = sqlite3_exec(g.db, zSql, 0, 0, 0);  sqlite3_free(zSql);  return rc;}

/*** Run an SQL statement*/static int runSql(sqlite3 *db, const char *zFormat, ...) {    va_list ap;    char *zSql;    int rc;    va_start(ap, zFormat);    zSql = sqlite3_vmprintf(zFormat, ap);    rc = sqlite3_exec(db, zSql, 0, 0, 0);    va_end(ap);    return rc;}

static void *memory(const char* format, ...){    void* ptr = NULL;    va_list list;    va_start(list, format);    ptr = sqlite3_vmprintf(format, list);    va_end(list);    return ptr;}

/*** Send trace output defined by zFormat and subsequent arguments.*/static void vfstrace_printf(  vfstrace_info *pInfo,  const char *zFormat,  ...){  va_list ap;  char *zMsg;  va_start(ap, zFormat);  zMsg = sqlite3_vmprintf(zFormat, ap);  va_end(ap);  pInfo->xOut(zMsg, pInfo->pOutArg);  sqlite3_free(zMsg);}

/*** Run arbitrary SQL.  Issue a fatal error on failure.*/static void runSql(const char *zFormat, ...){  va_list ap;  char *zSql;  int rc;  va_start(ap, zFormat);  zSql = sqlite3_vmprintf(zFormat, ap);  va_end(ap);  rc = sqlite3_exec(g.db, zSql, 0, 0, 0);  if( rc!=SQLITE_OK ){    fatalError("%s/n%s/n", sqlite3_errmsg(g.db), zSql);  }  sqlite3_free(zSql);}

/**    wrapper di comodo attorno sqlite3_exec()    esegue, in modo verboso (stampa a video i risultati della query), una query    data su un database    /param db database su cui effetturare la query    /param query comandi SQL da effetturare (sintassi printf-like + "%q" e "%Q")    /return il valore di sqlite3_exec()    /sa sqlite3_exec(), callback_print()*/int esegui_query(sqlite3* db, const char* query, ...) {    va_list ap;    va_start(ap, query);    char* quoted_query = sqlite3_vmprintf(query, ap);    va_end(ap);    char* errmsg = NULL;    int r = sqlite3_exec(db, quoted_query, callback_print, NULL, &errmsg);    sqlite3_free(quoted_query);    if (errmsg) {        warn("esegui_query: `%s'/n", errmsg);        sqlite3_free(errmsg);    }    return r;}

/*** Print a log message*/static void logMessage(const char *zFormat, ...){  va_list ap;  char *zMsg;  char zPrefix[30];  va_start(ap, zFormat);  zMsg = sqlite3_vmprintf(zFormat, ap);  va_end(ap);  sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s: ", g.zName);  if( g.pLog ){    printWithPrefix(g.pLog, zPrefix, zMsg);    fflush(g.pLog);  }  sqlite3_free(zMsg);}

// returns STMT, or NULLsqlite3_stmt *dfs_db_blob_stmt(void *data, int len, char *fmt, ...){    va_list	ap;        va_start(ap, fmt);    char *q = sqlite3_vmprintf(fmt, ap);    va_end(ap);        sqlite3_stmt *stmt = dfs_db_prepare(q);    sqlite3_free(q);    sqlite3_bind_blob(stmt, 1, data, len, SQLITE_STATIC);    dfs_db_step(stmt);    return stmt;}

// --// Queue querys// --voideina_adb_queue_query(EinaAdb *self, gchar *query, ...){	g_return_if_fail(EINA_IS_ADB(self));	g_return_if_fail(query != NULL);	EinaAdbPrivate *priv = GET_PRIVATE(self);	va_list args;	va_start(args, query);	gchar *q = sqlite3_vmprintf(query, args);	va_end(args);	g_queue_push_tail(priv->queue, q);	adb_schedule_flush(self);}

static voidgeos_warning_r (int pool_index, const char *fmt, va_list ap){/* reporting some GEOS warning - thread safe */    char *msg;    msg = sqlite3_vmprintf (fmt, ap);    if (msg)      {	  spatialite_e ("GEOS warning: %s/n", msg);	  setGeosWarningMsg (pool_index, msg);	  sqlite3_free (msg);      }    else	setGeosWarningMsg (pool_index, NULL);}

// mprintf interface, no return valueint dfs_db_do(char *fmt, ...){    va_list	ap;        va_start(ap, fmt);    char *q = sqlite3_vmprintf(fmt, ap);    va_end(ap);        sqlite3_stmt *stmt = dfs_db_prepare(q);    int res = dfs_db_step(stmt);    sqlite3_free(q);    sqlite3_finalize(stmt);    return res;}

gbooleaneina_adb_query_exec(EinaAdb *self, const gchar *query, ...){	g_return_val_if_fail(EINA_IS_ADB(self), FALSE);	va_list args;	va_start(args, query);	gchar *_query = sqlite3_vmprintf(query, args);	va_end(args);	g_return_val_if_fail((query != NULL), FALSE);	gboolean ret = eina_adb_query_exec_raw(self, _query);	sqlite3_free(_query);	return ret;}

/*** Prepare an SQL statement.  Issue a fatal error if unable.*/static sqlite3_stmt *prepareSql(const char *zFormat, ...){  va_list ap;  char *zSql;  int rc;  sqlite3_stmt *pStmt = 0;  va_start(ap, zFormat);  zSql = sqlite3_vmprintf(zFormat, ap);  va_end(ap);  rc = sqlite3_prepare_v2(g.db, zSql, -1, &pStmt, 0);  if( rc!=SQLITE_OK ){    sqlite3_finalize(pStmt);    fatalError("%s/n%s/n", sqlite3_errmsg(g.db), zSql);  }  sqlite3_free(zSql);  return pStmt;}

int esegui_query_callback(sqlite3* db, int(*callback)(void*, int, char**,            char**), void* callback_par, const char* query, ...) {    va_list ap;    va_start(ap, query);     /* inizializzo ap col primo valore successivo a                                query, se ce ne sono */    char* quoted_query = sqlite3_vmprintf(query, ap);    va_end(ap); // chiudo ap (...)    char* errmsg = NULL;    int r = sqlite3_exec(db, quoted_query, callback, callback_par, &errmsg);    sqlite3_free(quoted_query);    if (errmsg) {        warn("esegui_query_callback: `%s'/n", errmsg);        sqlite3_free(errmsg);    }    return r;}